From c7e15269309e064750c1bd029ce8e46c9e70ea18 Mon Sep 17 00:00:00 2001 From: f4exb Date: Tue, 16 Jan 2018 00:01:38 +0100 Subject: [PATCH] Added decimation class with unsigned to signed conversion with shift. Applied to RTL-SDR --- plugins/samplesource/rtlsdr/rtlsdrthread.cpp | 7 +- plugins/samplesource/rtlsdr/rtlsdrthread.h | 6 +- sdrbase/CMakeLists.txt | 1 + sdrbase/dsp/decimatorsu.h | 1323 ++++++++++++++++++ 4 files changed, 1329 insertions(+), 8 deletions(-) create mode 100644 sdrbase/dsp/decimatorsu.h diff --git a/plugins/samplesource/rtlsdr/rtlsdrthread.cpp b/plugins/samplesource/rtlsdr/rtlsdrthread.cpp index 46ec77e11..6c1ee8a17 100644 --- a/plugins/samplesource/rtlsdr/rtlsdrthread.cpp +++ b/plugins/samplesource/rtlsdr/rtlsdrthread.cpp @@ -88,7 +88,7 @@ void RTLSDRThread::run() } // Decimate according to specified log2 (ex: log2=4 => decim=16) -void RTLSDRThread::callback(const qint8* buf, qint32 len) +void RTLSDRThread::callback(const quint8* buf, qint32 len) { SampleVector::iterator it = m_convertBuffer.begin(); @@ -178,9 +178,6 @@ void RTLSDRThread::callback(const qint8* buf, qint32 len) void RTLSDRThread::callbackHelper(unsigned char* buf, uint32_t len, void* ctx) { RTLSDRThread* thread = (RTLSDRThread*)ctx; - for (unsigned int i = 0; i < len; i++) { - buf[i] = buf[i] - 127; - } - thread->callback((qint8 *) buf, len); + thread->callback(buf, len); } diff --git a/plugins/samplesource/rtlsdr/rtlsdrthread.h b/plugins/samplesource/rtlsdr/rtlsdrthread.h index 8a9debf5f..5c4d7ed9f 100644 --- a/plugins/samplesource/rtlsdr/rtlsdrthread.h +++ b/plugins/samplesource/rtlsdr/rtlsdrthread.h @@ -24,7 +24,7 @@ #include #include "dsp/samplesinkfifo.h" -#include "dsp/decimators.h" +#include "dsp/decimatorsu.h" class RTLSDRThread : public QThread { Q_OBJECT @@ -52,10 +52,10 @@ private: unsigned int m_log2Decim; int m_fcPos; - Decimators m_decimators; + DecimatorsU m_decimators; void run(); - void callback(const qint8* buf, qint32 len); + void callback(const quint8* buf, qint32 len); static void callbackHelper(unsigned char* buf, uint32_t len, void* ctx); }; diff --git a/sdrbase/CMakeLists.txt b/sdrbase/CMakeLists.txt index 9a47d4625..c5e123f1f 100644 --- a/sdrbase/CMakeLists.txt +++ b/sdrbase/CMakeLists.txt @@ -96,6 +96,7 @@ set(sdrbase_HEADERS dsp/cwkeyer.h dsp/cwkeyersettings.h dsp/decimators.h + dsp/decimatorsu.h dsp/interpolators.h dsp/dspcommands.h dsp/dspengine.h diff --git a/sdrbase/dsp/decimatorsu.h b/sdrbase/dsp/decimatorsu.h new file mode 100644 index 000000000..f288bc88c --- /dev/null +++ b/sdrbase/dsp/decimatorsu.h @@ -0,0 +1,1323 @@ +/////////////////////////////////////////////////////////////////////////////////// +// Copyright (C) 2018 Edouard Griffiths, F4EXB // +// // +// This program is free software; you can redistribute it and/or modify // +// it under the terms of the GNU General Public License as published by // +// the Free Software Foundation as version 3 of the License, or // +// // +// This program is distributed in the hope that it will be useful, // +// but WITHOUT ANY WARRANTY; without even the implied warranty of // +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // +// GNU General Public License V3 for more details. // +// // +// You should have received a copy of the GNU General Public License // +// along with this program. If not, see . // +// // +// This decimation class includes unsigned to signed with shifting. Typically // +// for 8 bit samples issued from RTL-SDR the conversion is: // +// signed = unsigned - 127. Here the "Shift" value is 127. // +// The shift value is given as a template parameter // +// // +/////////////////////////////////////////////////////////////////////////////////// + +#ifndef INCLUDE_GPL_DSP_DECIMATORSU_H_ +#define INCLUDE_GPL_DSP_DECIMATORSU_H_ + +#include "dsp/dsptypes.h" +#ifdef USE_SSE4_1 +#include "dsp/inthalfbandfiltereo1.h" +#else +#include "dsp/inthalfbandfilterdb.h" +#endif + +#define DECIMATORS_HB_FILTER_ORDER 64 + +template +struct decimation_shifts +{ + static const uint pre1 = 0; + static const uint pre2 = 0; + static const uint post2 = 0; + static const uint pre4 = 0; + static const uint post4 = 0; + static const uint pre8 = 0; + static const uint post8 = 0; + static const uint pre16 = 0; + static const uint post16 = 0; + static const uint pre32 = 0; + static const uint post32 = 0; + static const uint pre64 = 0; + static const uint post64 = 0; +}; + +template<> +struct decimation_shifts<16, 16> +{ + static const uint pre1 = 0; + static const uint pre2 = 0; + static const uint post2 = 1; + static const uint pre4 = 0; + static const uint post4 = 2; + static const uint pre8 = 0; + static const uint post8 = 3; + static const uint pre16 = 0; + static const uint post16 = 4; + static const uint pre32 = 0; + static const uint post32 = 5; + static const uint pre64 = 0; + static const uint post64 = 6; +}; + +template<> +struct decimation_shifts<16, 12> +{ + static const uint pre1 = 4; + static const uint pre2 = 3; + static const uint post2 = 0; + static const uint pre4 = 2; + static const uint post4 = 0; + static const uint pre8 = 1; + static const uint post8 = 0; + static const uint pre16 = 0; + static const uint post16 = 0; + static const uint pre32 = 0; + static const uint post32 = 1; + static const uint pre64 = 0; + static const uint post64 = 2; +}; + +template<> +struct decimation_shifts<16, 8> +{ + static const uint pre1 = 8; + static const uint pre2 = 7; + static const uint post2 = 0; + static const uint pre4 = 6; + static const uint post4 = 0; + static const uint pre8 = 5; + static const uint post8 = 0; + static const uint pre16 = 4; + static const uint post16 = 0; + static const uint pre32 = 3; + static const uint post32 = 0; + static const uint pre64 = 2; + static const uint post64 = 0; +}; + +template +class DecimatorsU +{ +public: + // interleaved I/Q input buffer + void decimate1(SampleVector::iterator* it, const T* buf, qint32 len); + void decimate2_inf(SampleVector::iterator* it, const T* buf, qint32 len); + void decimate2_sup(SampleVector::iterator* it, const T* buf, qint32 len); + void decimate2_cen(SampleVector::iterator* it, const T* buf, qint32 len); + void decimate4_inf(SampleVector::iterator* it, const T* buf, qint32 len); + void decimate4_sup(SampleVector::iterator* it, const T* buf, qint32 len); + void decimate4_cen(SampleVector::iterator* it, const T* buf, qint32 len); + void decimate8_inf(SampleVector::iterator* it, const T* buf, qint32 len); + void decimate8_sup(SampleVector::iterator* it, const T* buf, qint32 len); + void decimate8_cen(SampleVector::iterator* it, const T* buf, qint32 len); + void decimate16_inf(SampleVector::iterator* it, const T* buf, qint32 len); + void decimate16_sup(SampleVector::iterator* it, const T* buf, qint32 len); + void decimate16_cen(SampleVector::iterator* it, const T* buf, qint32 len); + void decimate32_inf(SampleVector::iterator* it, const T* buf, qint32 len); + void decimate32_sup(SampleVector::iterator* it, const T* buf, qint32 len); + void decimate32_cen(SampleVector::iterator* it, const T* buf, qint32 len); + void decimate64_inf(SampleVector::iterator* it, const T* buf, qint32 len); + void decimate64_sup(SampleVector::iterator* it, const T* buf, qint32 len); + void decimate64_cen(SampleVector::iterator* it, const T* buf, qint32 len); + +private: +#ifdef USE_SSE4_1 + IntHalfbandFilterEO1 m_decimator2; // 1st stages + IntHalfbandFilterEO1 m_decimator4; // 2nd stages + IntHalfbandFilterEO1 m_decimator8; // 3rd stages + IntHalfbandFilterEO1 m_decimator16; // 4th stages + IntHalfbandFilterEO1 m_decimator32; // 5th stages + IntHalfbandFilterEO1 m_decimator64; // 6th stages +#else + IntHalfbandFilterDB m_decimator2; // 1st stages + IntHalfbandFilterDB m_decimator4; // 2nd stages + IntHalfbandFilterDB m_decimator8; // 3rd stages + IntHalfbandFilterDB m_decimator16; // 4th stages + IntHalfbandFilterDB m_decimator32; // 5th stages + IntHalfbandFilterDB m_decimator64; // 6th stages +#endif +}; + +template +void DecimatorsU::decimate1(SampleVector::iterator* it, const T* buf, qint32 len) +{ + qint32 xreal, yimag; + + for (int pos = 0; pos < len - 1; pos += 2) + { + xreal = buf[pos+0] - Shift; + yimag = buf[pos+1] - Shift; + (**it).setReal(xreal << decimation_shifts::pre1); // Valgrind optim (2 - comment not repeated) + (**it).setImag(yimag << decimation_shifts::pre1); + ++(*it); // Valgrind optim (comment not repeated) + } +} + +template +void DecimatorsU::decimate2_inf(SampleVector::iterator* it, const T* buf, qint32 len) +{ + qint32 xreal, yimag; + + for (int pos = 0; pos < len - 7; pos += 8) + { + xreal = (buf[pos+0] - buf[pos+3]) << decimation_shifts::pre2; + yimag = (buf[pos+1] + buf[pos+2] - 2*Shift) << decimation_shifts::pre2; + (**it).setReal(xreal >> decimation_shifts::post2); + (**it).setImag(yimag >> decimation_shifts::post2); + ++(*it); + + xreal = (buf[pos+7] - buf[pos+4]) << decimation_shifts::pre2; + yimag = (2*Shift - buf[pos+5] - buf[pos+6]) << decimation_shifts::pre2; + (**it).setReal(xreal >> decimation_shifts::post2); + (**it).setImag(yimag >> decimation_shifts::post2); + ++(*it); + } +} + +template +void DecimatorsU::decimate2_sup(SampleVector::iterator* it, const T* buf, qint32 len) +{ + qint32 xreal, yimag; + + for (int pos = 0; pos < len - 7; pos += 8) + { + xreal = (buf[pos+1] - buf[pos+2]) << decimation_shifts::pre2; + yimag = (2*Shift - buf[pos+0] - buf[pos+3]) << decimation_shifts::pre2; + (**it).setReal(xreal >> decimation_shifts::post2); + (**it).setImag(yimag >> decimation_shifts::post2); + ++(*it); + + xreal = (buf[pos+6] - buf[pos+5]) << decimation_shifts::pre2; + yimag = (buf[pos+4] + buf[pos+7] - 2*Shift) << decimation_shifts::pre2; + (**it).setReal(xreal >> decimation_shifts::post2); + (**it).setImag(yimag >> decimation_shifts::post2); + ++(*it); + } +} + +template +void DecimatorsU::decimate4_inf(SampleVector::iterator* it, const T* buf, qint32 len) +{ + qint32 xreal, yimag; + + for (int pos = 0; pos < len - 7; pos += 8) + { + xreal = (buf[pos+0] - buf[pos+3] + buf[pos+7] - buf[pos+4]) << decimation_shifts::pre4; + yimag = (buf[pos+1] - buf[pos+5] + buf[pos+2] - buf[pos+6]) << decimation_shifts::pre4; + + (**it).setReal(xreal >> decimation_shifts::post4); + (**it).setImag(yimag >> decimation_shifts::post4); + + ++(*it); + } +} + +template +void DecimatorsU::decimate4_sup(SampleVector::iterator* it, const T* buf, qint32 len) +{ + // Sup (USB): + // x y x y x y x y / x -> 1,-2,-5,6 / y -> -0,-3,4,7 + // [ rotate: 1, 0, -2, 3, -5, -4, 6, -7] + // Inf (LSB): + // x y x y x y x y / x -> 0,-3,-4,7 / y -> 1,2,-5,-6 + // [ rotate: 0, 1, -3, 2, -4, -5, 7, -6] + qint32 xreal, yimag; + + for (int pos = 0; pos < len - 7; pos += 8) + { + xreal = (buf[pos+1] - buf[pos+2] - buf[pos+5] + buf[pos+6]) << decimation_shifts::pre4; + yimag = (- buf[pos+0] - buf[pos+3] + buf[pos+4] + buf[pos+7]) << decimation_shifts::pre4; + + (**it).setReal(xreal >> decimation_shifts::post4); + (**it).setImag(yimag >> decimation_shifts::post4); + + ++(*it); + } +} + +template +void DecimatorsU::decimate8_inf(SampleVector::iterator* it, const T* buf, qint32 len) +{ + qint32 xreal[2], yimag[2]; + + for (int pos = 0; pos < len - 15; pos += 8) + { + xreal[0] = (buf[pos+0] - buf[pos+3] + buf[pos+7] - buf[pos+4]) << decimation_shifts::pre8; + yimag[0] = (buf[pos+1] - buf[pos+5] + buf[pos+2] - buf[pos+6]) << decimation_shifts::pre8; + pos += 8; + + xreal[1] = (buf[pos+0] - buf[pos+3] + buf[pos+7] - buf[pos+4]) << decimation_shifts::pre8; + yimag[1] = (buf[pos+1] - buf[pos+5] + buf[pos+2] - buf[pos+6]) << decimation_shifts::pre8; + + m_decimator2.myDecimate(xreal[0], yimag[0], &xreal[1], &yimag[1]); + + (**it).setReal(xreal[1] >> decimation_shifts::post8); + (**it).setImag(yimag[1] >> decimation_shifts::post8); + + ++(*it); + } +} + +template +void DecimatorsU::decimate8_sup(SampleVector::iterator* it, const T* buf, qint32 len) +{ + qint32 xreal[2], yimag[2]; + + for (int pos = 0; pos < len - 15; pos += 8) + { + xreal[0] = (buf[pos+1] - buf[pos+2] - buf[pos+5] + buf[pos+6]) << decimation_shifts::pre8; + yimag[0] = (- buf[pos+0] - buf[pos+3] + buf[pos+4] + buf[pos+7]) << decimation_shifts::pre8; + pos += 8; + + xreal[1] = (buf[pos+1] - buf[pos+2] - buf[pos+5] + buf[pos+6]) << decimation_shifts::pre8; + yimag[1] = (- buf[pos+0] - buf[pos+3] + buf[pos+4] + buf[pos+7]) << decimation_shifts::pre8; + + m_decimator2.myDecimate(xreal[0], yimag[0], &xreal[1], &yimag[1]); + + (**it).setReal(xreal[1] >> decimation_shifts::post8); + (**it).setImag(yimag[1] >> decimation_shifts::post8); + + ++(*it); + } +} + +template +void DecimatorsU::decimate16_inf(SampleVector::iterator* it, const T* buf, qint32 len) +{ + // Offset tuning: 4x downsample and rotate, then + // downsample 4x more. [ rotate: 0, 1, -3, 2, -4, -5, 7, -6] + qint32 xreal[4], yimag[4]; + + for (int pos = 0; pos < len - 31; ) + { + for (int i = 0; i < 4; i++) + { + xreal[i] = (buf[pos+0] - buf[pos+3] + buf[pos+7] - buf[pos+4]) << decimation_shifts::pre16; + yimag[i] = (buf[pos+1] - buf[pos+5] + buf[pos+2] - buf[pos+6]) << decimation_shifts::pre16; + pos += 8; + } + + m_decimator2.myDecimate(xreal[0], yimag[0], &xreal[1], &yimag[1]); + m_decimator2.myDecimate(xreal[2], yimag[2], &xreal[3], &yimag[3]); + + m_decimator4.myDecimate(xreal[1], yimag[1], &xreal[3], &yimag[3]); + + (**it).setReal(xreal[3] >> decimation_shifts::post16); + (**it).setImag(yimag[3] >> decimation_shifts::post16); + + ++(*it); + } +} + +template +void DecimatorsU::decimate16_sup(SampleVector::iterator* it, const T* buf, qint32 len) +{ + // Offset tuning: 4x downsample and rotate, then + // downsample 4x more. [ rotate: 1, 0, -2, 3, -5, -4, 6, -7] + qint32 xreal[4], yimag[4]; + + for (int pos = 0; pos < len - 31; ) + { + for (int i = 0; i < 4; i++) + { + xreal[i] = (buf[pos+1] - buf[pos+2] - buf[pos+5] + buf[pos+6]) << decimation_shifts::pre16; + yimag[i] = (buf[pos+4] + buf[pos+7] - buf[pos+0] - buf[pos+3]) << decimation_shifts::pre16; + pos += 8; + } + + m_decimator2.myDecimate(xreal[0], yimag[0], &xreal[1], &yimag[1]); + m_decimator2.myDecimate(xreal[2], yimag[2], &xreal[3], &yimag[3]); + + m_decimator4.myDecimate(xreal[1], yimag[1], &xreal[3], &yimag[3]); + + (**it).setReal(xreal[3] >> decimation_shifts::post16); + (**it).setImag(yimag[3] >> decimation_shifts::post16); + + ++(*it); + } +} + +template +void DecimatorsU::decimate32_inf(SampleVector::iterator* it, const T* buf, qint32 len) +{ + qint32 xreal[8], yimag[8]; + + for (int pos = 0; pos < len - 63; ) + { + for (int i = 0; i < 8; i++) + { + xreal[i] = (buf[pos+0] - buf[pos+3] + buf[pos+7] - buf[pos+4]) << decimation_shifts::pre32; + yimag[i] = (buf[pos+1] - buf[pos+5] + buf[pos+2] - buf[pos+6]) << decimation_shifts::pre32; + pos += 8; + } + + m_decimator2.myDecimate(xreal[0], yimag[0], &xreal[1], &yimag[1]); + m_decimator2.myDecimate(xreal[2], yimag[2], &xreal[3], &yimag[3]); + m_decimator2.myDecimate(xreal[4], yimag[4], &xreal[5], &yimag[5]); + m_decimator2.myDecimate(xreal[6], yimag[6], &xreal[7], &yimag[7]); + + m_decimator4.myDecimate(xreal[1], yimag[1], &xreal[3], &yimag[3]); + m_decimator4.myDecimate(xreal[5], yimag[5], &xreal[7], &yimag[7]); + + m_decimator8.myDecimate(xreal[3], yimag[3], &xreal[7], &yimag[7]); + + (**it).setReal(xreal[7] >> decimation_shifts::post32); + (**it).setImag(yimag[7] >> decimation_shifts::post32); + + ++(*it); + } +} + +template +void DecimatorsU::decimate32_sup(SampleVector::iterator* it, const T* buf, qint32 len) +{ + qint32 xreal[8], yimag[8]; + + for (int pos = 0; pos < len - 63; ) + { + for (int i = 0; i < 8; i++) + { + xreal[i] = (buf[pos+1] - buf[pos+2] - buf[pos+5] + buf[pos+6]) << decimation_shifts::pre32; + yimag[i] = (buf[pos+4] + buf[pos+7] - buf[pos+0] - buf[pos+3]) << decimation_shifts::pre32; + pos += 8; + } + + m_decimator2.myDecimate(xreal[0], yimag[0], &xreal[1], &yimag[1]); + m_decimator2.myDecimate(xreal[2], yimag[2], &xreal[3], &yimag[3]); + m_decimator2.myDecimate(xreal[4], yimag[4], &xreal[5], &yimag[5]); + m_decimator2.myDecimate(xreal[6], yimag[6], &xreal[7], &yimag[7]); + + m_decimator4.myDecimate(xreal[1], yimag[1], &xreal[3], &yimag[3]); + m_decimator4.myDecimate(xreal[5], yimag[5], &xreal[7], &yimag[7]); + + m_decimator8.myDecimate(xreal[3], yimag[3], &xreal[7], &yimag[7]); + + (**it).setReal(xreal[7] >> decimation_shifts::post32); + (**it).setImag(yimag[7] >> decimation_shifts::post32); + + ++(*it); + } +} + +template +void DecimatorsU::decimate64_inf(SampleVector::iterator* it, const T* buf, qint32 len) +{ + qint32 xreal[16], yimag[16]; + + for (int pos = 0; pos < len - 127; ) + { + for (int i = 0; i < 16; i++) + { + xreal[i] = (buf[pos+0] - buf[pos+3] + buf[pos+7] - buf[pos+4]) << decimation_shifts::pre64; + yimag[i] = (buf[pos+1] - buf[pos+5] + buf[pos+2] - buf[pos+6]) << decimation_shifts::pre64; + pos += 8; + } + + m_decimator2.myDecimate(xreal[0], yimag[0], &xreal[1], &yimag[1]); + m_decimator2.myDecimate(xreal[2], yimag[2], &xreal[3], &yimag[3]); + m_decimator2.myDecimate(xreal[4], yimag[4], &xreal[5], &yimag[5]); + m_decimator2.myDecimate(xreal[6], yimag[6], &xreal[7], &yimag[7]); + m_decimator2.myDecimate(xreal[8], yimag[8], &xreal[9], &yimag[9]); + m_decimator2.myDecimate(xreal[10], yimag[10], &xreal[11], &yimag[11]); + m_decimator2.myDecimate(xreal[12], yimag[12], &xreal[13], &yimag[13]); + m_decimator2.myDecimate(xreal[14], yimag[14], &xreal[15], &yimag[15]); + + m_decimator4.myDecimate(xreal[1], yimag[1], &xreal[3], &yimag[3]); + m_decimator4.myDecimate(xreal[5], yimag[5], &xreal[7], &yimag[7]); + m_decimator4.myDecimate(xreal[9], yimag[9], &xreal[11], &yimag[11]); + m_decimator4.myDecimate(xreal[13], yimag[13], &xreal[15], &yimag[15]); + + m_decimator8.myDecimate(xreal[3], yimag[3], &xreal[7], &yimag[7]); + m_decimator8.myDecimate(xreal[11], yimag[11], &xreal[15], &yimag[15]); + + m_decimator16.myDecimate(xreal[7], yimag[7], &xreal[15], &yimag[15]); + + (**it).setReal(xreal[15] >> decimation_shifts::post64); + (**it).setImag(yimag[15] >> decimation_shifts::post64); + + ++(*it); + } +} + +template +void DecimatorsU::decimate64_sup(SampleVector::iterator* it, const T* buf, qint32 len) +{ + qint32 xreal[16], yimag[16]; + + for (int pos = 0; pos < len - 127; ) + { + for (int i = 0; i < 16; i++) + { + xreal[i] = (buf[pos+1] - buf[pos+2] - buf[pos+5] + buf[pos+6]) << decimation_shifts::pre32; + yimag[i] = (buf[pos+4] + buf[pos+7] - buf[pos+0] - buf[pos+3]) << decimation_shifts::pre32; + pos += 8; + } + + m_decimator2.myDecimate(xreal[0], yimag[0], &xreal[1], &yimag[1]); + m_decimator2.myDecimate(xreal[2], yimag[2], &xreal[3], &yimag[3]); + m_decimator2.myDecimate(xreal[4], yimag[4], &xreal[5], &yimag[5]); + m_decimator2.myDecimate(xreal[6], yimag[6], &xreal[7], &yimag[7]); + m_decimator2.myDecimate(xreal[8], yimag[8], &xreal[9], &yimag[9]); + m_decimator2.myDecimate(xreal[10], yimag[10], &xreal[11], &yimag[11]); + m_decimator2.myDecimate(xreal[12], yimag[12], &xreal[13], &yimag[13]); + m_decimator2.myDecimate(xreal[14], yimag[14], &xreal[15], &yimag[15]); + + m_decimator4.myDecimate(xreal[1], yimag[1], &xreal[3], &yimag[3]); + m_decimator4.myDecimate(xreal[5], yimag[5], &xreal[7], &yimag[7]); + m_decimator4.myDecimate(xreal[9], yimag[9], &xreal[11], &yimag[11]); + m_decimator4.myDecimate(xreal[13], yimag[13], &xreal[15], &yimag[15]); + + m_decimator8.myDecimate(xreal[3], yimag[3], &xreal[7], &yimag[7]); + m_decimator8.myDecimate(xreal[11], yimag[11], &xreal[15], &yimag[15]); + + m_decimator16.myDecimate(xreal[7], yimag[7], &xreal[15], &yimag[15]); + + (**it).setReal(xreal[15] >> decimation_shifts::post64); + (**it).setImag(yimag[15] >> decimation_shifts::post64); + + ++(*it); + } +} + +template +void DecimatorsU::decimate2_cen(SampleVector::iterator* it, const T* buf, qint32 len) +{ + qint32 intbuf[2]; + + for (int pos = 0; pos < len - 3; pos += 4) + { + intbuf[0] = (buf[pos+2] - Shift) << decimation_shifts::pre2; + intbuf[1] = (buf[pos+3] - Shift) << decimation_shifts::pre2; + + m_decimator2.myDecimate( + (buf[pos+0] - Shift) << decimation_shifts::pre2, + (buf[pos+1] - Shift) << decimation_shifts::pre2, + &intbuf[0], + &intbuf[1]); + + (**it).setReal(intbuf[0] >> decimation_shifts::post2); + (**it).setImag(intbuf[1] >> decimation_shifts::post2); + ++(*it); + } +} + +template +void DecimatorsU::decimate4_cen(SampleVector::iterator* it, const T* buf, qint32 len) +{ + qint32 intbuf[4]; + + for (int pos = 0; pos < len - 7; pos += 8) + { + intbuf[0] = (buf[pos+2] - Shift) << decimation_shifts::pre4; + intbuf[1] = (buf[pos+3] - Shift) << decimation_shifts::pre4; + intbuf[2] = (buf[pos+6] - Shift) << decimation_shifts::pre4; + intbuf[3] = (buf[pos+7] - Shift) << decimation_shifts::pre4; + + m_decimator2.myDecimate( + (buf[pos+0] - Shift) << decimation_shifts::pre4, + (buf[pos+1] - Shift) << decimation_shifts::pre4, + &intbuf[0], + &intbuf[1]); + m_decimator2.myDecimate( + (buf[pos+4] - Shift) << decimation_shifts::pre4, + (buf[pos+5] - Shift) << decimation_shifts::pre4, + &intbuf[2], + &intbuf[3]); + + m_decimator4.myDecimate( + intbuf[0], + intbuf[1], + &intbuf[2], + &intbuf[3]); + + (**it).setReal(intbuf[2] >> decimation_shifts::post4); + (**it).setImag(intbuf[3] >> decimation_shifts::post4); + ++(*it); + } +} + +template +void DecimatorsU::decimate8_cen(SampleVector::iterator* it, const T* buf, qint32 len) +{ + qint32 intbuf[8]; + + for (int pos = 0; pos < len - 15; pos += 16) + { + intbuf[0] = (buf[pos+2] - Shift) << decimation_shifts::pre8; + intbuf[1] = (buf[pos+3] - Shift) << decimation_shifts::pre8; + intbuf[2] = (buf[pos+6] - Shift) << decimation_shifts::pre8; + intbuf[3] = (buf[pos+7] - Shift) << decimation_shifts::pre8; + intbuf[4] = (buf[pos+10] - Shift) << decimation_shifts::pre8; + intbuf[5] = (buf[pos+11] - Shift) << decimation_shifts::pre8; + intbuf[6] = (buf[pos+14] - Shift) << decimation_shifts::pre8; + intbuf[7] = (buf[pos+15] - Shift) << decimation_shifts::pre8; + + m_decimator2.myDecimate( + (buf[pos+0] - Shift) << decimation_shifts::pre8, + (buf[pos+1] - Shift) << decimation_shifts::pre8, + &intbuf[0], + &intbuf[1]); + m_decimator2.myDecimate( + (buf[pos+4] - Shift) << decimation_shifts::pre8, + (buf[pos+5] - Shift) << decimation_shifts::pre8, + &intbuf[2], + &intbuf[3]); + m_decimator2.myDecimate( + (buf[pos+8] - Shift) << decimation_shifts::pre8, + (buf[pos+9] - Shift) << decimation_shifts::pre8, + &intbuf[4], + &intbuf[5]); + m_decimator2.myDecimate( + (buf[pos+12] - Shift) << decimation_shifts::pre8, + (buf[pos+13] - Shift) << decimation_shifts::pre8, + &intbuf[6], + &intbuf[7]); + + m_decimator4.myDecimate( + intbuf[0], + intbuf[1], + &intbuf[2], + &intbuf[3]); + m_decimator4.myDecimate( + intbuf[4], + intbuf[5], + &intbuf[6], + &intbuf[7]); + + m_decimator8.myDecimate( + intbuf[2], + intbuf[3], + &intbuf[6], + &intbuf[7]); + + (**it).setReal(intbuf[6] >> decimation_shifts::post8); + (**it).setImag(intbuf[7] >> decimation_shifts::post8); + ++(*it); + } +} + +template +void DecimatorsU::decimate16_cen(SampleVector::iterator* it, const T* buf, qint32 len) +{ + qint32 intbuf[16]; + + for (int pos = 0; pos < len - 31; pos += 32) + { + intbuf[0] = (buf[pos+2] - Shift) << decimation_shifts::pre16; + intbuf[1] = (buf[pos+3] - Shift) << decimation_shifts::pre16; + intbuf[2] = (buf[pos+6] - Shift) << decimation_shifts::pre16; + intbuf[3] = (buf[pos+7] - Shift) << decimation_shifts::pre16; + intbuf[4] = (buf[pos+10] - Shift) << decimation_shifts::pre16; + intbuf[5] = (buf[pos+11] - Shift) << decimation_shifts::pre16; + intbuf[6] = (buf[pos+14] - Shift) << decimation_shifts::pre16; + intbuf[7] = (buf[pos+15] - Shift) << decimation_shifts::pre16; + intbuf[8] = (buf[pos+18] - Shift) << decimation_shifts::pre16; + intbuf[9] = (buf[pos+19] - Shift) << decimation_shifts::pre16; + intbuf[10] = (buf[pos+22] - Shift) << decimation_shifts::pre16; + intbuf[11] = (buf[pos+23] - Shift) << decimation_shifts::pre16; + intbuf[12] = (buf[pos+26] - Shift) << decimation_shifts::pre16; + intbuf[13] = (buf[pos+27] - Shift) << decimation_shifts::pre16; + intbuf[14] = (buf[pos+30] - Shift) << decimation_shifts::pre16; + intbuf[15] = (buf[pos+31] - Shift) << decimation_shifts::pre16; + + m_decimator2.myDecimate( + (buf[pos+0] - Shift) << decimation_shifts::pre16, + (buf[pos+1] - Shift) << decimation_shifts::pre16, + &intbuf[0], + &intbuf[1]); + m_decimator2.myDecimate( + (buf[pos+4] - Shift) << decimation_shifts::pre16, + (buf[pos+5] - Shift) << decimation_shifts::pre16, + &intbuf[2], + &intbuf[3]); + m_decimator2.myDecimate( + (buf[pos+8] - Shift) << decimation_shifts::pre16, + (buf[pos+9] - Shift) << decimation_shifts::pre16, + &intbuf[4], + &intbuf[5]); + m_decimator2.myDecimate( + (buf[pos+12] - Shift) << decimation_shifts::pre16, + (buf[pos+13] - Shift) << decimation_shifts::pre16, + &intbuf[6], + &intbuf[7]); + m_decimator2.myDecimate( + (buf[pos+16] - Shift) << decimation_shifts::pre16, + (buf[pos+17] - Shift) << decimation_shifts::pre16, + &intbuf[8], + &intbuf[9]); + m_decimator2.myDecimate( + (buf[pos+20] - Shift) << decimation_shifts::pre16, + (buf[pos+21] - Shift) << decimation_shifts::pre16, + &intbuf[10], + &intbuf[11]); + m_decimator2.myDecimate( + (buf[pos+24] - Shift) << decimation_shifts::pre16, + (buf[pos+25] - Shift) << decimation_shifts::pre16, + &intbuf[12], + &intbuf[13]); + m_decimator2.myDecimate( + (buf[pos+28] - Shift) << decimation_shifts::pre16, + (buf[pos+29] - Shift) << decimation_shifts::pre16, + &intbuf[14], + &intbuf[15]); + + m_decimator4.myDecimate( + intbuf[0], + intbuf[1], + &intbuf[2], + &intbuf[3]); + m_decimator4.myDecimate( + intbuf[4], + intbuf[5], + &intbuf[6], + &intbuf[7]); + m_decimator4.myDecimate( + intbuf[8], + intbuf[9], + &intbuf[10], + &intbuf[11]); + m_decimator4.myDecimate( + intbuf[12], + intbuf[13], + &intbuf[14], + &intbuf[15]); + + m_decimator8.myDecimate( + intbuf[2], + intbuf[3], + &intbuf[6], + &intbuf[7]); + m_decimator8.myDecimate( + intbuf[10], + intbuf[11], + &intbuf[14], + &intbuf[15]); + + m_decimator16.myDecimate( + intbuf[6], + intbuf[7], + &intbuf[14], + &intbuf[15]); + + (**it).setReal(intbuf[14] >> decimation_shifts::post16); + (**it).setImag(intbuf[15] >> decimation_shifts::post16); + ++(*it); + } +} + +template +void DecimatorsU::decimate32_cen(SampleVector::iterator* it, const T* buf, qint32 len) +{ + qint32 intbuf[32]; + + for (int pos = 0; pos < len - 63; pos += 64) + { + intbuf[0] = (buf[pos+2] - Shift) << decimation_shifts::pre32; + intbuf[1] = (buf[pos+3] - Shift) << decimation_shifts::pre32; + intbuf[2] = (buf[pos+6] - Shift) << decimation_shifts::pre32; + intbuf[3] = (buf[pos+7] - Shift) << decimation_shifts::pre32; + intbuf[4] = (buf[pos+10] - Shift) << decimation_shifts::pre32; + intbuf[5] = (buf[pos+11] - Shift) << decimation_shifts::pre32; + intbuf[6] = (buf[pos+14] - Shift) << decimation_shifts::pre32; + intbuf[7] = (buf[pos+15] - Shift) << decimation_shifts::pre32; + intbuf[8] = (buf[pos+18] - Shift) << decimation_shifts::pre32; + intbuf[9] = (buf[pos+19] - Shift) << decimation_shifts::pre32; + intbuf[10] = (buf[pos+22] - Shift) << decimation_shifts::pre32; + intbuf[11] = (buf[pos+23] - Shift) << decimation_shifts::pre32; + intbuf[12] = (buf[pos+26] - Shift) << decimation_shifts::pre32; + intbuf[13] = (buf[pos+27] - Shift) << decimation_shifts::pre32; + intbuf[14] = (buf[pos+30] - Shift) << decimation_shifts::pre32; + intbuf[15] = (buf[pos+31] - Shift) << decimation_shifts::pre32; + intbuf[16] = (buf[pos+34] - Shift) << decimation_shifts::pre32; + intbuf[17] = (buf[pos+35] - Shift) << decimation_shifts::pre32; + intbuf[18] = (buf[pos+38] - Shift) << decimation_shifts::pre32; + intbuf[19] = (buf[pos+39] - Shift) << decimation_shifts::pre32; + intbuf[20] = (buf[pos+42] - Shift) << decimation_shifts::pre32; + intbuf[21] = (buf[pos+43] - Shift) << decimation_shifts::pre32; + intbuf[22] = (buf[pos+46] - Shift) << decimation_shifts::pre32; + intbuf[23] = (buf[pos+47] - Shift) << decimation_shifts::pre32; + intbuf[24] = (buf[pos+50] - Shift) << decimation_shifts::pre32; + intbuf[25] = (buf[pos+51] - Shift) << decimation_shifts::pre32; + intbuf[26] = (buf[pos+54] - Shift) << decimation_shifts::pre32; + intbuf[27] = (buf[pos+55] - Shift) << decimation_shifts::pre32; + intbuf[28] = (buf[pos+58] - Shift) << decimation_shifts::pre32; + intbuf[29] = (buf[pos+59] - Shift) << decimation_shifts::pre32; + intbuf[30] = (buf[pos+62] - Shift) << decimation_shifts::pre32; + intbuf[31] = (buf[pos+63] - Shift) << decimation_shifts::pre32; + + m_decimator2.myDecimate( + (buf[pos+0] - Shift) << decimation_shifts::pre32, + (buf[pos+1] - Shift) << decimation_shifts::pre32, + &intbuf[0], + &intbuf[1]); + m_decimator2.myDecimate( + (buf[pos+4] - Shift) << decimation_shifts::pre32, + (buf[pos+5] - Shift) << decimation_shifts::pre32, + &intbuf[2], + &intbuf[3]); + m_decimator2.myDecimate( + (buf[pos+8] - Shift) << decimation_shifts::pre32, + (buf[pos+9] - Shift) << decimation_shifts::pre32, + &intbuf[4], + &intbuf[5]); + m_decimator2.myDecimate( + (buf[pos+12] - Shift) << decimation_shifts::pre32, + (buf[pos+13] - Shift) << decimation_shifts::pre32, + &intbuf[6], + &intbuf[7]); + m_decimator2.myDecimate( + (buf[pos+16] - Shift) << decimation_shifts::pre32, + (buf[pos+17] - Shift) << decimation_shifts::pre32, + &intbuf[8], + &intbuf[9]); + m_decimator2.myDecimate( + (buf[pos+20] - Shift) << decimation_shifts::pre32, + (buf[pos+21] - Shift) << decimation_shifts::pre32, + &intbuf[10], + &intbuf[11]); + m_decimator2.myDecimate( + (buf[pos+24] - Shift) << decimation_shifts::pre32, + (buf[pos+25] - Shift) << decimation_shifts::pre32, + &intbuf[12], + &intbuf[13]); + m_decimator2.myDecimate( + (buf[pos+28] - Shift) << decimation_shifts::pre32, + (buf[pos+29] - Shift) << decimation_shifts::pre32, + &intbuf[14], + &intbuf[15]); + m_decimator2.myDecimate( + (buf[pos+32] - Shift) << decimation_shifts::pre32, + (buf[pos+33] - Shift) << decimation_shifts::pre32, + &intbuf[16], + &intbuf[17]); + m_decimator2.myDecimate( + (buf[pos+36] - Shift) << decimation_shifts::pre32, + (buf[pos+37] - Shift) << decimation_shifts::pre32, + &intbuf[18], + &intbuf[19]); + m_decimator2.myDecimate( + (buf[pos+40] - Shift) << decimation_shifts::pre32, + (buf[pos+41] - Shift) << decimation_shifts::pre32, + &intbuf[20], + &intbuf[21]); + m_decimator2.myDecimate( + (buf[pos+44] - Shift) << decimation_shifts::pre32, + (buf[pos+45] - Shift) << decimation_shifts::pre32, + &intbuf[22], + &intbuf[23]); + m_decimator2.myDecimate( + (buf[pos+48] - Shift) << decimation_shifts::pre32, + (buf[pos+49] - Shift) << decimation_shifts::pre32, + &intbuf[24], + &intbuf[25]); + m_decimator2.myDecimate( + (buf[pos+52] - Shift) << decimation_shifts::pre32, + (buf[pos+53] - Shift) << decimation_shifts::pre32, + &intbuf[26], + &intbuf[27]); + m_decimator2.myDecimate( + (buf[pos+56] - Shift) << decimation_shifts::pre32, + (buf[pos+57] - Shift) << decimation_shifts::pre32, + &intbuf[28], + &intbuf[29]); + m_decimator2.myDecimate( + (buf[pos+60] - Shift) << decimation_shifts::pre32, + (buf[pos+61] - Shift) << decimation_shifts::pre32, + &intbuf[30], + &intbuf[31]); + + m_decimator4.myDecimate( + intbuf[0], + intbuf[1], + &intbuf[2], + &intbuf[3]); + m_decimator4.myDecimate( + intbuf[4], + intbuf[5], + &intbuf[6], + &intbuf[7]); + m_decimator4.myDecimate( + intbuf[8], + intbuf[9], + &intbuf[10], + &intbuf[11]); + m_decimator4.myDecimate( + intbuf[12], + intbuf[13], + &intbuf[14], + &intbuf[15]); + m_decimator4.myDecimate( + intbuf[16], + intbuf[17], + &intbuf[18], + &intbuf[19]); + m_decimator4.myDecimate( + intbuf[20], + intbuf[21], + &intbuf[22], + &intbuf[23]); + m_decimator4.myDecimate( + intbuf[24], + intbuf[25], + &intbuf[26], + &intbuf[27]); + m_decimator4.myDecimate( + intbuf[28], + intbuf[29], + &intbuf[30], + &intbuf[31]); + + m_decimator8.myDecimate( + intbuf[2], + intbuf[3], + &intbuf[6], + &intbuf[7]); + m_decimator8.myDecimate( + intbuf[10], + intbuf[11], + &intbuf[14], + &intbuf[15]); + m_decimator8.myDecimate( + intbuf[18], + intbuf[19], + &intbuf[22], + &intbuf[23]); + m_decimator8.myDecimate( + intbuf[26], + intbuf[27], + &intbuf[30], + &intbuf[31]); + + m_decimator16.myDecimate( + intbuf[6], + intbuf[7], + &intbuf[14], + &intbuf[15]); + m_decimator16.myDecimate( + intbuf[22], + intbuf[23], + &intbuf[30], + &intbuf[31]); + + m_decimator32.myDecimate( + intbuf[14], + intbuf[15], + &intbuf[30], + &intbuf[31]); + + (**it).setReal(intbuf[30] >> decimation_shifts::post32); + (**it).setImag(intbuf[31] >> decimation_shifts::post32); + ++(*it); + } +} + +template +void DecimatorsU::decimate64_cen(SampleVector::iterator* it, const T* buf, qint32 len) +{ + qint32 intbuf[64]; + + for (int pos = 0; pos < len - 127; pos += 128) + { + intbuf[0] = (buf[pos+2] - Shift) << decimation_shifts::pre64; + intbuf[1] = (buf[pos+3] - Shift) << decimation_shifts::pre64; + intbuf[2] = (buf[pos+6] - Shift) << decimation_shifts::pre64; + intbuf[3] = (buf[pos+7] - Shift) << decimation_shifts::pre64; + intbuf[4] = (buf[pos+10] - Shift) << decimation_shifts::pre64; + intbuf[5] = (buf[pos+11] - Shift) << decimation_shifts::pre64; + intbuf[6] = (buf[pos+14] - Shift) << decimation_shifts::pre64; + intbuf[7] = (buf[pos+15] - Shift) << decimation_shifts::pre64; + intbuf[8] = (buf[pos+18] - Shift) << decimation_shifts::pre64; + intbuf[9] = (buf[pos+19] - Shift) << decimation_shifts::pre64; + intbuf[10] = (buf[pos+22] - Shift) << decimation_shifts::pre64; + intbuf[11] = (buf[pos+23] - Shift) << decimation_shifts::pre64; + intbuf[12] = (buf[pos+26] - Shift) << decimation_shifts::pre64; + intbuf[13] = (buf[pos+27] - Shift) << decimation_shifts::pre64; + intbuf[14] = (buf[pos+30] - Shift) << decimation_shifts::pre64; + intbuf[15] = (buf[pos+31] - Shift) << decimation_shifts::pre64; + intbuf[16] = (buf[pos+34] - Shift) << decimation_shifts::pre64; + intbuf[17] = (buf[pos+35] - Shift) << decimation_shifts::pre64; + intbuf[18] = (buf[pos+38] - Shift) << decimation_shifts::pre64; + intbuf[19] = (buf[pos+39] - Shift) << decimation_shifts::pre64; + intbuf[20] = (buf[pos+42] - Shift) << decimation_shifts::pre64; + intbuf[21] = (buf[pos+43] - Shift) << decimation_shifts::pre64; + intbuf[22] = (buf[pos+46] - Shift) << decimation_shifts::pre64; + intbuf[23] = (buf[pos+47] - Shift) << decimation_shifts::pre64; + intbuf[24] = (buf[pos+50] - Shift) << decimation_shifts::pre64; + intbuf[25] = (buf[pos+51] - Shift) << decimation_shifts::pre64; + intbuf[26] = (buf[pos+54] - Shift) << decimation_shifts::pre64; + intbuf[27] = (buf[pos+55] - Shift) << decimation_shifts::pre64; + intbuf[28] = (buf[pos+58] - Shift) << decimation_shifts::pre64; + intbuf[29] = (buf[pos+59] - Shift) << decimation_shifts::pre64; + intbuf[30] = (buf[pos+62] - Shift) << decimation_shifts::pre64; + intbuf[31] = (buf[pos+63] - Shift) << decimation_shifts::pre64; + + intbuf[32] = (buf[pos+66] - Shift) << decimation_shifts::pre64; + intbuf[33] = (buf[pos+67] - Shift) << decimation_shifts::pre64; + intbuf[34] = (buf[pos+70] - Shift) << decimation_shifts::pre64; + intbuf[35] = (buf[pos+71] - Shift) << decimation_shifts::pre64; + intbuf[36] = (buf[pos+74] - Shift) << decimation_shifts::pre64; + intbuf[37] = (buf[pos+75] - Shift) << decimation_shifts::pre64; + intbuf[38] = (buf[pos+78] - Shift) << decimation_shifts::pre64; + intbuf[39] = (buf[pos+79] - Shift) << decimation_shifts::pre64; + intbuf[40] = (buf[pos+82] - Shift) << decimation_shifts::pre64; + intbuf[41] = (buf[pos+83] - Shift) << decimation_shifts::pre64; + intbuf[42] = (buf[pos+86] - Shift) << decimation_shifts::pre64; + intbuf[43] = (buf[pos+87] - Shift) << decimation_shifts::pre64; + intbuf[44] = (buf[pos+90] - Shift) << decimation_shifts::pre64; + intbuf[45] = (buf[pos+91] - Shift) << decimation_shifts::pre64; + intbuf[46] = (buf[pos+94] - Shift) << decimation_shifts::pre64; + intbuf[47] = (buf[pos+95] - Shift) << decimation_shifts::pre64; + intbuf[48] = (buf[pos+98] - Shift) << decimation_shifts::pre64; + intbuf[49] = (buf[pos+99] - Shift) << decimation_shifts::pre64; + intbuf[50] = (buf[pos+102] - Shift) << decimation_shifts::pre64; + intbuf[51] = (buf[pos+103] - Shift) << decimation_shifts::pre64; + intbuf[52] = (buf[pos+106] - Shift) << decimation_shifts::pre64; + intbuf[53] = (buf[pos+107] - Shift) << decimation_shifts::pre64; + intbuf[54] = (buf[pos+110] - Shift) << decimation_shifts::pre64; + intbuf[55] = (buf[pos+111] - Shift) << decimation_shifts::pre64; + intbuf[56] = (buf[pos+114] - Shift) << decimation_shifts::pre64; + intbuf[57] = (buf[pos+115] - Shift) << decimation_shifts::pre64; + intbuf[58] = (buf[pos+118] - Shift) << decimation_shifts::pre64; + intbuf[59] = (buf[pos+119] - Shift) << decimation_shifts::pre64; + intbuf[60] = (buf[pos+122] - Shift) << decimation_shifts::pre64; + intbuf[61] = (buf[pos+123] - Shift) << decimation_shifts::pre64; + intbuf[62] = (buf[pos+126] - Shift) << decimation_shifts::pre64; + intbuf[63] = (buf[pos+127] - Shift) << decimation_shifts::pre64; + + m_decimator2.myDecimate( + (buf[pos+0] - Shift) << decimation_shifts::pre64, + (buf[pos+1] - Shift) << decimation_shifts::pre64, + &intbuf[0], + &intbuf[1]); + m_decimator2.myDecimate( + (buf[pos+4] - Shift) << decimation_shifts::pre64, + (buf[pos+5] - Shift) << decimation_shifts::pre64, + &intbuf[2], + &intbuf[3]); + m_decimator2.myDecimate( + (buf[pos+8] - Shift) << decimation_shifts::pre64, + (buf[pos+9] - Shift) << decimation_shifts::pre64, + &intbuf[4], + &intbuf[5]); + m_decimator2.myDecimate( + (buf[pos+12] - Shift) << decimation_shifts::pre64, + (buf[pos+13] - Shift) << decimation_shifts::pre64, + &intbuf[6], + &intbuf[7]); + m_decimator2.myDecimate( + (buf[pos+16] - Shift) << decimation_shifts::pre64, + (buf[pos+17] - Shift) << decimation_shifts::pre64, + &intbuf[8], + &intbuf[9]); + m_decimator2.myDecimate( + (buf[pos+20] - Shift) << decimation_shifts::pre64, + (buf[pos+21] - Shift) << decimation_shifts::pre64, + &intbuf[10], + &intbuf[11]); + m_decimator2.myDecimate( + (buf[pos+24] - Shift) << decimation_shifts::pre64, + (buf[pos+25] - Shift) << decimation_shifts::pre64, + &intbuf[12], + &intbuf[13]); + m_decimator2.myDecimate( + (buf[pos+28] - Shift) << decimation_shifts::pre64, + (buf[pos+29] - Shift) << decimation_shifts::pre64, + &intbuf[14], + &intbuf[15]); + m_decimator2.myDecimate( + (buf[pos+32] - Shift) << decimation_shifts::pre64, + (buf[pos+33] - Shift) << decimation_shifts::pre64, + &intbuf[16], + &intbuf[17]); + m_decimator2.myDecimate( + (buf[pos+36] - Shift) << decimation_shifts::pre64, + (buf[pos+37] - Shift) << decimation_shifts::pre64, + &intbuf[18], + &intbuf[19]); + m_decimator2.myDecimate( + (buf[pos+40] - Shift) << decimation_shifts::pre64, + (buf[pos+41] - Shift) << decimation_shifts::pre64, + &intbuf[20], + &intbuf[21]); + m_decimator2.myDecimate( + (buf[pos+44] - Shift) << decimation_shifts::pre64, + (buf[pos+45] - Shift) << decimation_shifts::pre64, + &intbuf[22], + &intbuf[23]); + m_decimator2.myDecimate( + (buf[pos+48] - Shift) << decimation_shifts::pre64, + (buf[pos+49] - Shift) << decimation_shifts::pre64, + &intbuf[24], + &intbuf[25]); + m_decimator2.myDecimate( + (buf[pos+52] - Shift) << decimation_shifts::pre64, + (buf[pos+53] - Shift) << decimation_shifts::pre64, + &intbuf[26], + &intbuf[27]); + m_decimator2.myDecimate( + (buf[pos+56] - Shift) << decimation_shifts::pre64, + (buf[pos+57] - Shift) << decimation_shifts::pre64, + &intbuf[28], + &intbuf[29]); + m_decimator2.myDecimate( + (buf[pos+60] - Shift) << decimation_shifts::pre64, + (buf[pos+61] - Shift) << decimation_shifts::pre64, + &intbuf[30], + &intbuf[31]); + m_decimator2.myDecimate( + (buf[pos+64] - Shift) << decimation_shifts::pre64, + (buf[pos+65] - Shift) << decimation_shifts::pre64, + &intbuf[32], + &intbuf[33]); + m_decimator2.myDecimate( + (buf[pos+68] - Shift) << decimation_shifts::pre64, + (buf[pos+69] - Shift) << decimation_shifts::pre64, + &intbuf[34], + &intbuf[35]); + m_decimator2.myDecimate( + (buf[pos+72] - Shift) << decimation_shifts::pre64, + (buf[pos+73] - Shift) << decimation_shifts::pre64, + &intbuf[36], + &intbuf[37]); + m_decimator2.myDecimate( + (buf[pos+76] - Shift) << decimation_shifts::pre64, + (buf[pos+77] - Shift) << decimation_shifts::pre64, + &intbuf[38], + &intbuf[39]); + m_decimator2.myDecimate( + (buf[pos+80] - Shift) << decimation_shifts::pre64, + (buf[pos+81] - Shift) << decimation_shifts::pre64, + &intbuf[40], + &intbuf[41]); + m_decimator2.myDecimate( + (buf[pos+84] - Shift) << decimation_shifts::pre64, + (buf[pos+85] - Shift) << decimation_shifts::pre64, + &intbuf[42], + &intbuf[43]); + m_decimator2.myDecimate( + (buf[pos+88] - Shift) << decimation_shifts::pre64, + (buf[pos+89] - Shift) << decimation_shifts::pre64, + &intbuf[44], + &intbuf[45]); + m_decimator2.myDecimate( + (buf[pos+92] - Shift) << decimation_shifts::pre64, + (buf[pos+93] - Shift) << decimation_shifts::pre64, + &intbuf[46], + &intbuf[47]); + m_decimator2.myDecimate( + (buf[pos+96] - Shift) << decimation_shifts::pre64, + (buf[pos+97] - Shift) << decimation_shifts::pre64, + &intbuf[48], + &intbuf[49]); + m_decimator2.myDecimate( + (buf[pos+100] - Shift) << decimation_shifts::pre64, + (buf[pos+101] - Shift) << decimation_shifts::pre64, + &intbuf[50], + &intbuf[51]); + m_decimator2.myDecimate( + (buf[pos+104] - Shift) << decimation_shifts::pre64, + (buf[pos+105] - Shift) << decimation_shifts::pre64, + &intbuf[52], + &intbuf[53]); + m_decimator2.myDecimate( + (buf[pos+108] - Shift) << decimation_shifts::pre64, + (buf[pos+109] - Shift) << decimation_shifts::pre64, + &intbuf[54], + &intbuf[55]); + m_decimator2.myDecimate( + (buf[pos+112] - Shift) << decimation_shifts::pre64, + (buf[pos+113] - Shift) << decimation_shifts::pre64, + &intbuf[56], + &intbuf[57]); + m_decimator2.myDecimate( + (buf[pos+116] - Shift) << decimation_shifts::pre64, + (buf[pos+117] - Shift) << decimation_shifts::pre64, + &intbuf[58], + &intbuf[59]); + m_decimator2.myDecimate( + (buf[pos+120] - Shift) << decimation_shifts::pre64, + (buf[pos+121] - Shift) << decimation_shifts::pre64, + &intbuf[60], + &intbuf[61]); + m_decimator2.myDecimate( + (buf[pos+124] - Shift) << decimation_shifts::pre64, + (buf[pos+125] - Shift) << decimation_shifts::pre64, + &intbuf[62], + &intbuf[63]); + + m_decimator4.myDecimate( + intbuf[0], + intbuf[1], + &intbuf[2], + &intbuf[3]); + m_decimator4.myDecimate( + intbuf[4], + intbuf[5], + &intbuf[6], + &intbuf[7]); + m_decimator4.myDecimate( + intbuf[8], + intbuf[9], + &intbuf[10], + &intbuf[11]); + m_decimator4.myDecimate( + intbuf[12], + intbuf[13], + &intbuf[14], + &intbuf[15]); + m_decimator4.myDecimate( + intbuf[16], + intbuf[17], + &intbuf[18], + &intbuf[19]); + m_decimator4.myDecimate( + intbuf[20], + intbuf[21], + &intbuf[22], + &intbuf[23]); + m_decimator4.myDecimate( + intbuf[24], + intbuf[25], + &intbuf[26], + &intbuf[27]); + m_decimator4.myDecimate( + intbuf[28], + intbuf[29], + &intbuf[30], + &intbuf[31]); + m_decimator4.myDecimate( + intbuf[32], + intbuf[33], + &intbuf[34], + &intbuf[35]); + m_decimator4.myDecimate( + intbuf[36], + intbuf[37], + &intbuf[38], + &intbuf[39]); + m_decimator4.myDecimate( + intbuf[40], + intbuf[41], + &intbuf[42], + &intbuf[43]); + m_decimator4.myDecimate( + intbuf[44], + intbuf[45], + &intbuf[46], + &intbuf[47]); + m_decimator4.myDecimate( + intbuf[48], + intbuf[49], + &intbuf[50], + &intbuf[51]); + m_decimator4.myDecimate( + intbuf[52], + intbuf[53], + &intbuf[54], + &intbuf[55]); + m_decimator4.myDecimate( + intbuf[56], + intbuf[57], + &intbuf[58], + &intbuf[59]); + m_decimator4.myDecimate( + intbuf[60], + intbuf[61], + &intbuf[62], + &intbuf[63]); + + m_decimator8.myDecimate( + intbuf[2], + intbuf[3], + &intbuf[6], + &intbuf[7]); + m_decimator8.myDecimate( + intbuf[10], + intbuf[11], + &intbuf[14], + &intbuf[15]); + m_decimator8.myDecimate( + intbuf[18], + intbuf[19], + &intbuf[22], + &intbuf[23]); + m_decimator8.myDecimate( + intbuf[26], + intbuf[27], + &intbuf[30], + &intbuf[31]); + m_decimator8.myDecimate( + intbuf[34], + intbuf[35], + &intbuf[38], + &intbuf[39]); + m_decimator8.myDecimate( + intbuf[42], + intbuf[43], + &intbuf[46], + &intbuf[47]); + m_decimator8.myDecimate( + intbuf[50], + intbuf[51], + &intbuf[54], + &intbuf[55]); + m_decimator8.myDecimate( + intbuf[58], + intbuf[59], + &intbuf[62], + &intbuf[63]); + + m_decimator16.myDecimate( + intbuf[6], + intbuf[7], + &intbuf[14], + &intbuf[15]); + m_decimator16.myDecimate( + intbuf[22], + intbuf[23], + &intbuf[30], + &intbuf[31]); + m_decimator16.myDecimate( + intbuf[38], + intbuf[39], + &intbuf[46], + &intbuf[47]); + m_decimator16.myDecimate( + intbuf[54], + intbuf[55], + &intbuf[62], + &intbuf[63]); + + m_decimator32.myDecimate( + intbuf[14], + intbuf[15], + &intbuf[30], + &intbuf[31]); + m_decimator32.myDecimate( + intbuf[46], + intbuf[47], + &intbuf[62], + &intbuf[63]); + + m_decimator64.myDecimate( + intbuf[30], + intbuf[31], + &intbuf[62], + &intbuf[63]); + + (**it).setReal(intbuf[62] >> decimation_shifts::post64); + (**it).setImag(intbuf[63] >> decimation_shifts::post64); + ++(*it); + } +} + +#endif /* INCLUDE_GPL_DSP_DECIMATORSU_H_ */