diff --git a/Source/Receiver.cpp b/Source/Receiver.cpp
index 30694c9..e8870cc 100644
--- a/Source/Receiver.cpp
+++ b/Source/Receiver.cpp
@@ -270,9 +270,6 @@ void Receiver::free()
 
 	m_ReceiverEnable = false;
 
-	NCO_Free(&m_nco_ddc);
-	NCO_Free(&m_nco_cpr);
-
 	// Symbol demapper
 	if (m_pSymMapper)
 	{
@@ -363,7 +360,7 @@ void Receiver::timerCallback()
 	}
 }
 
-void Receiver::processPassband(float *pRF, uint32_t len)
+void Receiver::processPassband(RVec const &rf, uint32_t len)
 {
 	const ScopedLock sl (m_lock);
 
@@ -378,7 +375,7 @@ void Receiver::processPassband(float *pRF, uint32_t len)
 	test4normal = 0;
 	for (uint32_t i=0; i < len; i++)
 	{
-		test4normal += pRF[i];
+		test4normal += rf[i];
 	}
 	if (isnan(test4normal))
 	{
@@ -395,12 +392,7 @@ void Receiver::processPassband(float *pRF, uint32_t len)
 
 	// Digital Down Converter
 	// @samplerate
-	NCO_MixRealComplexV(&m_nco_ddc, m_pPassbandBuffer, pRF, 2/*m_params.agcGain[0]*/, len);
-	
-	for (uint32_t i=0; i < len; i++)
-	{
-		m_passbandBuffer[i] = ComplexScalar(m_pPassbandBuffer[i].real, m_pPassbandBuffer[i].imag);
-	}
+	m_nco_ddc.mixRealComplexV(m_passbandBuffer, rf, RealScalar(2)/*m_params.agcGain[0]*/, len);
 
 	// Arm Filtering and downsampling
 	len_down = m_firArmDown.process(m_basebandBuffer, m_passbandBuffer, len);
@@ -502,8 +494,8 @@ void Receiver::processBaseband(CVec const &iq, uint32_t len)
 			Vd = STRGardnerProcess(&m_SymbolTimingRevovery, IQ_agc);
 
 			// Carrier Derotator
-			IQ_cpr = NCO_MixComplexS(&m_nco_cpr, IQ_agc, Cpx(1,1));
-			NCO_Process(&m_nco_cpr, m_dOmega_vco, m_params.CPR_phase);
+			IQ_cpr = toCpx(m_nco_cpr.mixComplexS(toComplexScalar(IQ_agc), ComplexScalar(1,1)));
+			m_nco_cpr.process(m_dOmega_vco, m_params.CPR_phase);
 
 			if (TimingCorrectorIsSkip(&m_timing_corrector))
 			{
@@ -693,13 +685,13 @@ void Receiver::processBaseband(CVec const &iq, uint32_t len)
 
 void Receiver::initDDC()
 {
-	NCO_Init(&m_nco_ddc, m_params.ddc_freq/m_params.samplerate, 0);
+	m_nco_ddc.init(m_params.ddc_freq/m_params.samplerate, 0);
 }
 
 void Receiver::initCPR()
 {
 	PfdInit(&m_pfdCpr);
-	NCO_Init(&m_nco_cpr, 0, 0);
+	m_nco_cpr.init(0, 0);
 	LeadLagInit(&m_loop_filter_cpr, 0.0);
 	m_dOmega_vco = 0.0;
 }
diff --git a/Source/Receiver.h b/Source/Receiver.h
index a39f2bc..fa7c2e8 100644
--- a/Source/Receiver.h
+++ b/Source/Receiver.h
@@ -3,11 +3,9 @@
 
 #include <cstdint>
 #include <radio/symbol.h>
-#include <radio/nco.h>
 #include <radio/synchronization.h>
 #include <radio/interpolation.h>
 #include <radio/statistics.h>
-#include <radio/equalizer.h>
 #include <radio/agc.h>
 #include <radio/Frame.hpp>
 
@@ -17,6 +15,7 @@
 #include <radio/FirComplex.hpp>
 #include <radio/Equalizer.hpp>
 #include <radio/Interpolation.hpp>
+#include <radio/Nco.hpp>
 
 using namespace Radio;
 
@@ -270,7 +269,7 @@ public:
 	void init();
 	void free();
 	void processBaseband(float *pI, float *pQ, uint32_t len);
-	void processPassband(float *pRF, uint32_t len);
+	void processPassband(RVec const &rf, uint32_t len);
 	void setBufSize(uint32 size);
 	uint32 getNumSoftSym();
 	sym_err_t getSoftSym(uint32 index);
@@ -305,7 +304,7 @@ private:
 	Interpolation::Farrow m_farrow;
 
 	// NCOs
-	nco_t m_nco_ddc, m_nco_cpr;
+	Nco m_nco_ddc, m_nco_cpr;
 	radio_float_t m_dOmega_vco;
 	
 	// Loop-Filter
diff --git a/Source/Transmitter.cpp b/Source/Transmitter.cpp
index 4e84be0..32e83ea 100644
--- a/Source/Transmitter.cpp
+++ b/Source/Transmitter.cpp
@@ -7,20 +7,17 @@ Transmitter::Transmitter(void)
 	, m_formatter(&m_symbolizer)
 	, m_symbolMapper()
 	, m_bufferSize(0)
-	, m_bufferRF(0)
-	, m_bufferSymRcf(0)
-	, m_bufferSym(0)
 	, m_samplerate(192000)
 	, m_symbolrate(48000)
 	, m_numBitPerSymbol(2)
 	, m_carrierFreq(48000)
 	, m_txBuf(0, 2)
 	, m_symCount(0)
-	, m_CoeffRCF(0)
+	, m_pCoeffRCF(0)
+	, m_upsampleFactor(1)
 {
 	SymMapInit(&m_symbolMapper, m_numBitPerSymbol, MAP_MODE_QAM);
-	FirCpxMultirateUpInit(&m_firUpRcf, NULL, 0, 1);
-	NCO_Init(&m_duc, m_carrierFreq/m_samplerate, 0);
+	m_duc.init(m_carrierFreq/m_samplerate, 0);
 
 	paramChanged();
 
@@ -31,30 +28,16 @@ Transmitter::~Transmitter(void)
 {
 	stopThread(1000);
 
-	if (m_bufferRF)
-		delete m_bufferRF;
+	if (m_pCoeffRCF)
+		delete m_pCoeffRCF;
 
-	if (m_bufferSymRcf)
-		delete m_bufferSymRcf;
+	m_pCoeffRCF = nullptr;
 
-	if (m_bufferSym)
-		delete m_bufferSym;
-
-	if (m_CoeffRCF)
-		delete m_CoeffRCF;
-
-	m_bufferRF = nullptr;
-	m_bufferSymRcf = nullptr;
-	m_bufferSym = nullptr;
-	m_CoeffRCF = nullptr;
-
-	FirCpxMultirateFree(&m_firUpRcf);
 	SymMapFree(&m_symbolMapper);
 }
 
 void Transmitter::paramChanged()
 {
-	uint32_t M_up;
 	uint32_t n_mf;
 
 	const ScopedLock sl (m_lock);
@@ -62,54 +45,30 @@ void Transmitter::paramChanged()
 	m_symbolizer.setNumBitsPerSymbol(m_numBitPerSymbol);
 	SymMapReinit(&m_symbolMapper, m_numBitPerSymbol, MAP_MODE_QAM);
 
-	M_up = (uint32_t)(m_samplerate/m_symbolrate + 0.5);
-	n_mf = (uint32_t)(TRANSMITTER_RCF_OVERSAMPLING*M_up) + 1;
+	m_upsampleFactor = (uint32_t)(m_samplerate/m_symbolrate + 0.5);
+	n_mf = (uint32_t)(TRANSMITTER_RCF_OVERSAMPLING*m_upsampleFactor) + 1;
 
-	if (m_CoeffRCF)
-		delete m_CoeffRCF;
+	if (m_pCoeffRCF)
+		delete m_pCoeffRCF;
 
-	m_CoeffRCF = new radio_float_t[n_mf];
-	m_kRcf = CalcFirSRRC(m_CoeffRCF, (radio_float_t)m_samplerate, (radio_float_t)2.0/m_symbolrate, TRANSMITTER_RCF_ROLLOFF, n_mf);
-
-	FirCpxMultirateUpReinit(&m_firUpRcf, m_CoeffRCF, n_mf, M_up);
-
-	NCO_Reinit(&m_duc, m_carrierFreq/m_samplerate, 0);
+	m_pCoeffRCF = new radio_float_t[n_mf];
+	m_kRcf = CalcFirSRRC(m_pCoeffRCF, (radio_float_t)m_samplerate, (radio_float_t)2.0/m_symbolrate, TRANSMITTER_RCF_ROLLOFF, n_mf);
 
+	m_firUp.init(m_upsampleFactor, m_pCoeffRCF, n_mf);
+	m_duc.init(m_carrierFreq/m_samplerate, 0);
 }
 
 void Transmitter::bufferResize(uint32_t size)
 {
 	stopThread(10000);
 
-	m_txBuf.resize(size, 8);
-
-	if (size != m_bufferSize)
-	{
-		if (m_bufferRF)
-		{
-			delete m_bufferRF;
-			m_bufferRF = nullptr;
-		}
-		if (m_bufferSymRcf)
-		{
-			delete m_bufferSymRcf;
-			m_bufferSymRcf = nullptr;
-		}
-		if (m_bufferSym)
-		{
-			delete m_bufferSym;
-			m_bufferSym = nullptr;
-		}
-	}
-
 	m_bufferSize = size;
 
-	if (!size)
-		return;
-
-	m_bufferRF = new float[m_bufferSize];
-	m_bufferSymRcf = new cpx_t[m_bufferSize];
-	m_bufferSym = new cpx_t[m_bufferSize];
+	m_txBuf.resize(size, 8);
+	m_bufferRF.resize(size);
+	m_bufferSym.resize(size);
+	m_bufferSymRcf.resize(size);
+	
 	m_symCount = 0;
 	startThread(0);
 
diff --git a/Source/Transmitter.h b/Source/Transmitter.h
index 5c9bf83..7f8a993 100644
--- a/Source/Transmitter.h
+++ b/Source/Transmitter.h
@@ -3,13 +3,18 @@
 
 #include <cstdint>
 #include <radio/symbol.h>
-#include <radio/nco.h>
 #include <radio/interpolation.h>
 #include <radio/Frame.hpp>
 
 #include "JuceHeader.h"
 #include "LogComponent.h"
 
+#include <radio/Vector.hpp>
+#include <radio/Nco.hpp>
+#include <radio/Interpolation.hpp>
+
+using namespace Radio;
+
 #define TRANSMITTER_RCF_OVERSAMPLING		((uint32_t)32)
 #define TRANSMITTER_RCF_ROLLOFF				((radio_float_t)0.35)
 
@@ -48,7 +53,7 @@ public:
 		resize(0, 0);
 	}
 
-	void write(float *pData, uint32_t len)
+	void write(RVec const &data, uint32_t len)
 	{
 		uint32_t i;
 
@@ -61,7 +66,7 @@ public:
 		}
 		for (i=0; i < len; i++)
 		{
-			m_ppBuffer[m_w][i] = pData[i];
+			m_ppBuffer[m_w][i] = data[i];
 		}
 		m_w++;
 		if (m_w >= m_numBuffers)
@@ -149,21 +154,23 @@ private:
 	Symbolizer m_symbolizer;
 	Formatter m_formatter;
 	sym_map_t m_symbolMapper;
-	fir_cpx_multirate_t m_firUpRcf;
+	Interpolation::UpSampler m_firUp;
 	uint32_t m_bufferSize;
-	float *m_bufferRF;
-	cpx_t *m_bufferSymRcf;
-	cpx_t *m_bufferSym;
+	RVec m_bufferRF;
+	CVec m_bufferSym;
+	CVec m_bufferSymRcf;
 	float m_samplerate;
 	float m_ddcFrequency;
 	float m_symbolrate;
 	uint32_t m_numBitPerSymbol;
-	radio_float_t *m_CoeffRCF;
+	radio_float_t *m_pCoeffRCF;
 	radio_float_t m_kRcf;
 	radio_float_t m_carrierFreq;
-	nco_t m_duc;
+	Nco m_duc;
+	
 	TxBuffer m_txBuf;
 	uint32_t m_symCount;
+	uint32_t m_upsampleFactor;
 
 	// Thread
 	void run() override
@@ -184,12 +191,12 @@ private:
 		uint32_t symCountRcf;
 		const ScopedLock sl (m_lock);
 
-		m_bufferSym[m_symCount++] = SymMapMap(&m_symbolMapper, symbol);
+		m_bufferSym[m_symCount++] = toComplexScalar(SymMapMap(&m_symbolMapper, symbol));
 
-		if (m_symCount >= m_bufferSize/m_firUpRcf.L)
+		if (m_symCount >= m_bufferSize/m_upsampleFactor)
 		{
-			symCountRcf = FirCpxUpProcess(&m_firUpRcf, m_bufferSym, m_bufferSymRcf, m_symCount);
-			NCO_MixComplexRealV(&m_duc, m_bufferRF, m_bufferSymRcf, Cpx(m_kRcf/4, m_kRcf/4), symCountRcf);
+			symCountRcf = m_firUp.process(m_bufferSymRcf, m_bufferSym, m_symCount);
+			m_duc.mixComplexRealV(m_bufferRF, m_bufferSymRcf, ComplexScalar(m_kRcf/4, m_kRcf/4), symCountRcf);
 			m_txBuf.write(m_bufferRF, symCountRcf);
 			m_symCount = 0;
 		}
@@ -217,7 +224,7 @@ private:
 	{
 		const ScopedLock sl (m_lock);
 		m_carrierFreq = frequency_hz;
-		NCO_Reinit(&m_duc, m_carrierFreq/m_samplerate, 0);
+		m_duc.init(m_carrierFreq/m_samplerate, 0);
 	}
 	void setSymbolRate(float symbolrate_bit_per_sec) override
 	{