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

   1 /* -*- c++ -*- */
   2 /*
   3  * Copyright 2005 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 /*
  24  * WARNING: This file is automatically generated by generate_gr_fft_filter_XXX.py
  25  * Any changes made to this file will be overwritten.
  26  */
  27
  28 #ifdef HAVE_CONFIG_H
  29 #include "config.h"
  30 #endif
  31
  32 #include <gr_fft_filter_ccc.h>
  33 #include <gr_io_signature.h>
  34 #include <gri_fft.h>
  35 #include <math.h>
  36 #include <assert.h>
  37 #include <stdexcept>
  38 #include <gr_firdes.h>
  39
  40 #include <cstdio>
  41 #include <iostream>
  42 #include <string.h>
  43
  44 gr_fft_filter_ccc_sptr gr_make_fft_filter_ccc (int decimation, const std::vector<gr_complex> &taps)
  45 {
  46   return gr_fft_filter_ccc_sptr (new gr_fft_filter_ccc (decimation, taps));
  47 }
  48
  49
  50 gr_fft_filter_ccc::gr_fft_filter_ccc (int decimation, const std::vector<gr_complex> &taps)
  51   : gr_sync_decimator ("fft_filter_ccc",
  52                        gr_make_io_signature (1, 1, sizeof (gr_complex)),
  53                        gr_make_io_signature (1, 1, sizeof (gr_complex)),
  54                        decimation),
  55     d_fftsize(-1), d_fwdfft(0), d_invfft(0), d_updated(false)
  56 {
  57   // if (decimation != 1)
  58   //    throw std::invalid_argument("gr_fft_filter_ccc: decimation must be 1");
  59
  60   set_history(1);
  61   actual_set_taps(taps);
  62 }
  63
  64 gr_fft_filter_ccc::~gr_fft_filter_ccc ()
  65 {
  66   delete d_fwdfft;
  67   delete d_invfft;
  68 }
  69
  70 #if 0
  71 static void
  72 print_vector_complex(const std::string label, const std::vector<gr_complex> &x)
  73 {
  74   std::cout << label;
  75   for (unsigned i = 0; i < x.size(); i++)
  76     std::cout << x[i] << " ";
  77   std::cout << "\n";
  78 }
  79 #endif
  80
  81 void
  82 gr_fft_filter_ccc::set_taps (const std::vector<gr_complex> &taps)
  83 {
  84   d_new_taps = taps;
  85   d_updated = true;
  86 }
  87
  88 /*
  89  * determines d_ntaps, d_nsamples, d_fftsize, d_xformed_taps
  90  */
  91 void
  92 gr_fft_filter_ccc::actual_set_taps (const std::vector<gr_complex> &taps)
  93 {
  94   int i = 0;
  95   compute_sizes(taps.size());
  96
  97   d_tail.resize(tailsize());
  98   for (i = 0; i < tailsize(); i++)
  99     d_tail[i] = 0;
 100
 101   gr_complex *in = d_fwdfft->get_inbuf();
 102   gr_complex *out = d_fwdfft->get_outbuf();
 103
 104   float scale = 1.0 / d_fftsize;
 105
 106   // Compute forward xform of taps.
 107   // Copy taps into first ntaps slots, then pad with zeros
 108   for (i = 0; i < d_ntaps; i++)
 109     in[i] = taps[i] * scale;
 110
 111   for (; i < d_fftsize; i++)
 112     in[i] = 0;
 113
 114   d_fwdfft->execute();          // do the xform
 115
 116   // now copy output to d_xformed_taps
 117   for (i = 0; i < d_fftsize; i++)
 118     d_xformed_taps[i] = out[i];
 119
 120   //print_vector_complex("transformed taps:", d_xformed_taps);
 121 }
 122
 123 // determine and set d_ntaps, d_nsamples, d_fftsize
 124
 125 void
 126 gr_fft_filter_ccc::compute_sizes(int ntaps)
 127 {
 128   int old_fftsize = d_fftsize;
 129   d_ntaps = ntaps;
 130   d_fftsize = (int) (2 * pow(2.0, ceil(log(ntaps) / log(2))));
 131   d_nsamples = d_fftsize - d_ntaps + 1;
 132
 133   if (0)
 134     fprintf(stderr, "gr_fft_filter: ntaps = %d, fftsize = %d, nsamples = %d\n",
 135             d_ntaps, d_fftsize, d_nsamples);
 136
 137   assert(d_fftsize == d_ntaps + d_nsamples -1 );
 138
 139   if (d_fftsize != old_fftsize){        // compute new plans
 140     delete d_fwdfft;
 141     delete d_invfft;
 142     d_fwdfft = new gri_fft_complex(d_fftsize, true);
 143     d_invfft = new gri_fft_complex(d_fftsize, false);
 144     d_xformed_taps.resize(d_fftsize);
 145   }
 146
 147   set_output_multiple(d_nsamples);
 148 }
 149
 150 int
 151 gr_fft_filter_ccc::work (int noutput_items,
 152                          gr_vector_const_void_star &input_items,
 153                          gr_vector_void_star &output_items)
 154 {
 155   gr_complex *in = (gr_complex *) input_items[0];
 156   gr_complex *out = (gr_complex *) output_items[0];
 157
 158   if (d_updated){
 159     actual_set_taps(d_new_taps);
 160     d_updated = false;
 161     return 0;                           // output multiple may have changed
 162   }
 163
 164   assert(noutput_items % d_nsamples == 0);
 165
 166   int dec_ctr = 0;
 167   int j = 0;
 168   int ninput_items = noutput_items * decimation();
 169
 170   for (int i = 0; i < ninput_items; i += d_nsamples){
 171
 172     memcpy(d_fwdfft->get_inbuf(), &in[i], d_nsamples * sizeof(gr_complex));
 173
 174     for (j = d_nsamples; j < d_fftsize; j++)
 175       d_fwdfft->get_inbuf()[j] = 0;
 176
 177     d_fwdfft->execute();        // compute fwd xform
 178
 179     gr_complex *a = d_fwdfft->get_outbuf();
 180     gr_complex *b = &d_xformed_taps[0];
 181     gr_complex *c = d_invfft->get_inbuf();
 182
 183     for (j = 0; j < d_fftsize; j++)     // filter in the freq domain
 184       c[j] = a[j] * b[j];
 185
 186     d_invfft->execute();        // compute inv xform
 187
 188     // add in the overlapping tail
 189
 190     for (j = 0; j < tailsize(); j++)
 191       d_invfft->get_outbuf()[j] += d_tail[j];
 192
 193     // copy nsamples to output
 194
 195     //memcpy(out, d_invfft->get_outbuf(), d_nsamples * sizeof(gr_complex));
 196     //out += d_nsamples;
 197
 198     j = dec_ctr;
 199     while (j < d_nsamples) {
 200       *out++ = d_invfft->get_outbuf()[j];
 201       j += decimation();
 202     }
 203     dec_ctr = (j - d_nsamples);
 204
 205     // stash the tail
 206     memcpy(&d_tail[0], d_invfft->get_outbuf() + d_nsamples,
 207            tailsize() * sizeof(gr_complex));
 208   }
 209
 210   assert((out - (gr_complex *) output_items[0]) == noutput_items);
 211   assert(dec_ctr == 0);
 212
 213   return noutput_items;
 214 }