osmo-trx-dec: Offline demodulation tool.

Change-Id: Ic5b59c7fe1a0c02d962b36de2fd5d7fc9a02f266

.gitignore

@@ -0,0 +1,48 @@
+# build results
+*.o
+*.lo
+*.la
+Transceiver52M/osmo-trx
+Transceiver52M/osmo-trx-gen
+Transceiver52M/osmo-trx-dec
+
+# tests
+CommonLibs/BitVectorTest
+CommonLibs/ConfigurationTest
+CommonLibs/F16Test
+CommonLibs/InterthreadTest
+CommonLibs/LogTest
+CommonLibs/RegexpTest
+CommonLibs/SocketsTest
+CommonLibs/TimevalTest
+CommonLibs/URLEncodeTest
+CommonLibs/VectorTest
+CommonLibs/PRBSTest
+
+# automake/autoconf
+*.in
+.deps
+.libs
+.dirstamp
+*~
+Makefile
+config.log
+config.status
+config.h
+config.guess
+config.sub
+config/*
+configure
+compile
+aclocal.m4
+autom4te.cache
+depcomp
+install-sh
+libtool
+ltmain.sh
+missing
+stamp-h1
+INSTALL
+
+# vim
+*.sw?

.gitreview

@@ -0,0 +1,3 @@
+[gerrit]
+host=gerrit.osmocom.org
+project=osmo-trx

CommonLibs/BitVector.cpp

@@ -30,6 +30,7 @@
 #include <iostream>
 #include <stdio.h>
 #include <sstream>
+#include <math.h>
 
 using namespace std;
 
@@ -199,49 +200,6 @@ void BitVector::LSB8MSB()
 
 
 
-uint64_t BitVector::syndrome(Generator& gen) const
-{
-	gen.clear();
-	const char *dp = mStart;
-	while (dp<mEnd) gen.syndromeShift(*dp++);
-	return gen.state();
-}
-
-
-uint64_t BitVector::parity(Generator& gen) const
-{
-	gen.clear();
-	const char *dp = mStart;
-	while (dp<mEnd) gen.encoderShift(*dp++);
-	return gen.state();
-}
-
-
-void BitVector::encode(const ViterbiR2O4& coder, BitVector& target)
-{
-	size_t sz = size();
-	assert(sz*coder.iRate() == target.size());
-
-	// Build a "history" array where each element contains the full history.
-	uint32_t history[sz];
-	uint32_t accum = 0;
-	for (size_t i=0; i<sz; i++) {
-		accum = (accum<<1) | bit(i);
-		history[i] = accum;
-	}
-
-	// Look up histories in the pre-generated state table.
-	char *op = target.begin();
-	for (size_t i=0; i<sz; i++) {
-		unsigned index = coder.cMask() & history[i];
-		for (unsigned g=0; g<coder.iRate(); g++) {
-			*op++ = coder.stateTable(g,index);
-		}
-	}
-}
-
-
-
 unsigned BitVector::sum() const
 {
 	unsigned sum = 0;
@@ -287,148 +245,12 @@ ostream& operator<<(ostream& os, const BitVector& hv)
 
 
 
-ViterbiR2O4::ViterbiR2O4()
-{
-	assert(mDeferral < 32);
-	mCoeffs[0] = 0x019;
-	mCoeffs[1] = 0x01b;
-	computeStateTables(0);
-	computeStateTables(1);
-	computeGeneratorTable();
-}
-
-
-
-
-void ViterbiR2O4::initializeStates()
-{
-	for (unsigned i=0; i<mIStates; i++) clear(mSurvivors[i]);
-	for (unsigned i=0; i<mNumCands; i++) clear(mCandidates[i]);
-}
-
-
-
-void ViterbiR2O4::computeStateTables(unsigned g)
-{
-	assert(g<mIRate);
-	for (unsigned state=0; state<mIStates; state++) {
-		// 0 input
-		uint32_t inputVal = state<<1;
-		mStateTable[g][inputVal] = applyPoly(inputVal, mCoeffs[g], mOrder+1);
-		// 1 input
-		inputVal |= 1;
-		mStateTable[g][inputVal] = applyPoly(inputVal, mCoeffs[g], mOrder+1);
-	}
-}
-
-void ViterbiR2O4::computeGeneratorTable()
-{
-	for (unsigned index=0; index<mIStates*2; index++) {
-		mGeneratorTable[index] = (mStateTable[0][index]<<1) | mStateTable[1][index];
-	}
-}
-
-
-
-
-
-
-void ViterbiR2O4::branchCandidates()
-{
-	// Branch to generate new input states.
-	const vCand *sp = mSurvivors;
-	for (unsigned i=0; i<mNumCands; i+=2) {
-		// extend and suffix
-		const uint32_t iState0 = (sp->iState) << 1;				// input state for 0
-		const uint32_t iState1 = iState0 | 0x01;				// input state for 1
-		const uint32_t oStateShifted = (sp->oState) << mIRate;	// shifted output
-		const float cost = sp->cost;
-		sp++;
-		// 0 input extension
-		mCandidates[i].cost = cost;
-		mCandidates[i].oState = oStateShifted | mGeneratorTable[iState0 & mCMask];
-		mCandidates[i].iState = iState0;
-		// 1 input extension
-		mCandidates[i+1].cost = cost;
-		mCandidates[i+1].oState = oStateShifted | mGeneratorTable[iState1 & mCMask];
-		mCandidates[i+1].iState = iState1;
-	}
-}
-
-
-void ViterbiR2O4::getSoftCostMetrics(const uint32_t inSample, const float *matchCost, const float *mismatchCost)
-{
-	const float *cTab[2] = {matchCost,mismatchCost};
-	for (unsigned i=0; i<mNumCands; i++) {
-		vCand& thisCand = mCandidates[i];
-		// We examine input bits 2 at a time for a rate 1/2 coder.
-		const unsigned mismatched = inSample ^ (thisCand.oState);
-		thisCand.cost += cTab[mismatched&0x01][1] + cTab[(mismatched>>1)&0x01][0];
-	}
-}
-
-
-void ViterbiR2O4::pruneCandidates()
-{
-	const vCand* c1 = mCandidates;					// 0-prefix
-	const vCand* c2 = mCandidates + mIStates;		// 1-prefix
-	for (unsigned i=0; i<mIStates; i++) {
-		if (c1[i].cost < c2[i].cost) mSurvivors[i] = c1[i];
-		else mSurvivors[i] = c2[i];
-	}
-}
-
-
-const ViterbiR2O4::vCand& ViterbiR2O4::minCost() const
-{
-	int minIndex = 0;
-	float minCost = mSurvivors[0].cost;
-	for (unsigned i=1; i<mIStates; i++) {
-		const float thisCost = mSurvivors[i].cost;
-		if (thisCost>=minCost) continue;
-		minCost = thisCost;
-		minIndex=i;
-	}
-	return mSurvivors[minIndex];
-}
-
-
-const ViterbiR2O4::vCand& ViterbiR2O4::step(uint32_t inSample, const float *probs, const float *iprobs)
-{
-	branchCandidates();
-	getSoftCostMetrics(inSample,probs,iprobs);
-	pruneCandidates();
-	return minCost();
-}
-
-
-uint64_t Parity::syndrome(const BitVector& receivedCodeword)
-{
-	return receivedCodeword.syndrome(*this);
-}
-
-
-void Parity::writeParityWord(const BitVector& data, BitVector& parityTarget, bool invert)
-{
-	uint64_t pWord = data.parity(*this);
-	if (invert) pWord = ~pWord; 
-	parityTarget.fillField(0,pWord,size());
-}
-
-
-
-
-
-
-
-
-
 SoftVector::SoftVector(const BitVector& source)
 {
 	resize(source.size());
 	for (size_t i=0; i<size(); i++) {
 		if (source.bit(i)) mStart[i]=1.0F;
-		else mStart[i]=0.0F;
+		else mStart[i]=-1.0F;
 	}
 }
 
@@ -438,102 +260,20 @@ BitVector SoftVector::sliced() const
 	size_t sz = size();
 	BitVector newSig(sz);
 	for (size_t i=0; i<sz; i++) {
-		if (mStart[i]>0.5F) newSig[i]=1;
+		if (mStart[i]>0.0F) newSig[i]=1;
 		else newSig[i] = 0;
 	}
 	return newSig;
 }
 
 
-
-void SoftVector::decode(ViterbiR2O4 &decoder, BitVector& target) const
-{
-	const size_t sz = size();
-	const unsigned deferral = decoder.deferral();
-	const size_t ctsz = sz + deferral*decoder.iRate();
-	assert(sz <= decoder.iRate()*target.size());
-
-	// Build a "history" array where each element contains the full history.
-	uint32_t history[ctsz];
-	{
-		BitVector bits = sliced();
-		uint32_t accum = 0;
-		for (size_t i=0; i<sz; i++) {
-			accum = (accum<<1) | bits.bit(i);
-			history[i] = accum;
-		}
-		// Repeat last bit at the end.
-		for (size_t i=sz; i<ctsz; i++) {
-			accum = (accum<<1) | (accum & 0x01);
-			history[i] = accum;
-		}
-	}
-
-	// Precompute metric tables.
-	float matchCostTable[ctsz];
-	float mismatchCostTable[ctsz];
-	{
-		const float *dp = mStart;
-		for (size_t i=0; i<sz; i++) {
-			// pVal is the probability that a bit is correct.
-			// ipVal is the probability that a bit is incorrect.
-			float pVal = dp[i];
-			if (pVal>0.5F) pVal = 1.0F-pVal;
-			float ipVal = 1.0F-pVal;
-			// This is a cheap approximation to an ideal cost function.
-			if (pVal<0.01F) pVal = 0.01;
-			if (ipVal<0.01F) ipVal = 0.01;
-			matchCostTable[i] = 0.25F/ipVal;
-			mismatchCostTable[i] = 0.25F/pVal;
-		}
-	
-		// pad end of table with unknowns
-		for (size_t i=sz; i<ctsz; i++) {
-			matchCostTable[i] = 0.5F;
-			mismatchCostTable[i] = 0.5F;
-		}
-	}
-
-	{
-		decoder.initializeStates();
-		// Each sample of history[] carries its history.
-		// So we only have to process every iRate-th sample.
-		const unsigned step = decoder.iRate();
-		// input pointer
-		const uint32_t *ip = history + step - 1;
-		// output pointers
-		char *op = target.begin();
-		const char *const opt = target.end();
-		// table pointers
-		const float* match = matchCostTable;
-		const float* mismatch = mismatchCostTable;
-		size_t oCount = 0;
-		while (op<opt) {
-			// Viterbi algorithm
-			assert(match-matchCostTable<sizeof(matchCostTable)/sizeof(matchCostTable[0])-1);
-			assert(mismatch-mismatchCostTable<sizeof(mismatchCostTable)/sizeof(mismatchCostTable[0])-1);
-			const ViterbiR2O4::vCand &minCost = decoder.step(*ip, match, mismatch);
-			ip += step;
-			match += step;
-			mismatch += step;
-			// output
-			if (oCount>=deferral) *op++ = (minCost.iState >> deferral)&0x01;
-			oCount++;
-		}
-	}
-}
-
-
-
-// (pat) Added 6-22-2012
 float SoftVector::getEnergy(float *plow) const
 {
 	const SoftVector &vec = *this;
 	int len = vec.size();
 	float avg = 0; float low = 1;
 	for (int i = 0; i < len; i++) {
-		float bit = vec[i];
-		float energy = 2*((bit < 0.5) ? (0.5-bit) : (bit-0.5));
+		float energy = fabsf(vec[i]);
 		if (energy < low) low = energy;
 		avg += energy/len;
 	}
@@ -545,8 +285,12 @@ float SoftVector::getEnergy(float *plow) const
 ostream& operator<<(ostream& os, const SoftVector& sv)
 {
 	for (size_t i=0; i<sv.size(); i++) {
-		if (sv[i]<0.25) os << "0";
-		else if (sv[i]>0.75) os << "1";
+		if (sv[i]<-0.5) os << "0";
+		else if (sv[i]<-0.25) os << "o";
+		else if (sv[i]<0.0) os << ".";
+		else if (sv[i]>0.5) os << "1";
+		else if (sv[i]>0.25) os << "|";
+		else if (sv[i]>0.0) os << "'";
 		else os << "-";
 	}
 	return os;

CommonLibs/BitVector.h

@@ -30,201 +30,6 @@
 #include <stdint.h>
 
 
-class BitVector;
-class SoftVector;
-
-
-
-/** Shift-register (LFSR) generator. */
-class Generator {
-
-	private:
-
-	uint64_t mCoeff;	///< polynomial coefficients. LSB is zero exponent.
-	uint64_t mState;	///< shift register state. LSB is most recent.
-	uint64_t mMask;		///< mask for reading state
-	unsigned mLen;		///< number of bits used in shift register
-	unsigned mLen_1;	///< mLen - 1
-
-	public:
-
-	Generator(uint64_t wCoeff, unsigned wLen)
-		:mCoeff(wCoeff),mState(0),
-		mMask((1ULL<<wLen)-1),
-		mLen(wLen),mLen_1(wLen-1)
-	{ assert(wLen<64); }
-
-	void clear() { mState=0; }
-
-	/**@name Accessors */
-	//@{
-	uint64_t state() const { return mState & mMask; }
-	unsigned size() const { return mLen; }
-	//@}
-
-	/**
-		Calculate one bit of a syndrome.
-		This is in the .h for inlining.
-	*/
-	void syndromeShift(unsigned inBit)
-	{
-		const unsigned fb = (mState>>(mLen_1)) & 0x01;
-		mState = (mState<<1) ^ (inBit & 0x01);
-		if (fb) mState ^= mCoeff;
-	}
-
-	/**
-		Update the generator state by one cycle.
-		This is in the .h for inlining.
-	*/
-	void encoderShift(unsigned inBit)
-	{
-		const unsigned fb = ((mState>>(mLen_1)) ^ inBit) & 0x01;
-		mState <<= 1;
-		if (fb) mState ^= mCoeff;
-	}
-
-
-};
-
-
-
-
-/** Parity (CRC-type) generator and checker based on a Generator. */
-class Parity : public Generator {
-
-	protected:
-
-	unsigned mCodewordSize;
-
-	public:
-
-	Parity(uint64_t wCoefficients, unsigned wParitySize, unsigned wCodewordSize)
-		:Generator(wCoefficients, wParitySize),
-		mCodewordSize(wCodewordSize)
-	{ }
-
-	/** Compute the parity word and write it into the target segment.  */
-	void writeParityWord(const BitVector& data, BitVector& parityWordTarget, bool invert=true);
-
-	/** Compute the syndrome of a received sequence. */
-	uint64_t syndrome(const BitVector& receivedCodeword);
-};
-
-
-
-
-/**
-	Class to represent convolutional coders/decoders of rate 1/2, memory length 4.
-	This is the "workhorse" coder for most GSM channels.
-*/
-class ViterbiR2O4 {
-
-	private:
-		/**name Lots of precomputed elements so the compiler can optimize like hell. */
-		//@{
-		/**@name Core values. */
-		//@{
-		static const unsigned mIRate = 2;	///< reciprocal of rate
-		static const unsigned mOrder = 4;	///< memory length of generators
-		//@}
-		/**@name Derived values. */
-		//@{
-		static const unsigned mIStates = 0x01 << mOrder;	///< number of states, number of survivors
-		static const uint32_t mSMask = mIStates-1;			///< survivor mask
-		static const uint32_t mCMask = (mSMask<<1) | 0x01;	///< candidate mask
-		static const uint32_t mOMask = (0x01<<mIRate)-1;	///< ouput mask, all iRate low bits set
-		static const unsigned mNumCands = mIStates*2;		///< number of candidates to generate during branching
-		static const unsigned mDeferral = 6*mOrder;			///< deferral to be used
-		//@}
-		//@}
-
-		/** Precomputed tables. */
-		//@{
-		uint32_t mCoeffs[mIRate];					///< polynomial for each generator
-		uint32_t mStateTable[mIRate][2*mIStates];	///< precomputed generator output tables
-		uint32_t mGeneratorTable[2*mIStates];		///< precomputed coder output table
-		//@}
-	
-	public:
-
-		/**
-		  A candidate sequence in a Viterbi decoder.
-		  The 32-bit state register can support a deferral of 6 with a 4th-order coder.
-		 */
-		typedef struct candStruct {
-			uint32_t iState;	///< encoder input associated with this candidate
-			uint32_t oState;	///< encoder output associated with this candidate
-			float cost;			///< cost (metric value), float to support soft inputs
-		} vCand;
-
-		/** Clear a structure. */
-		void clear(vCand& v)
-		{
-			v.iState=0;
-			v.oState=0;
-			v.cost=0;
-		}
-		
-
-	private:
-
-		/**@name Survivors and candidates. */
-		//@{
-		vCand mSurvivors[mIStates];			///< current survivor pool
-		vCand mCandidates[2*mIStates];		///< current candidate pool
-		//@}
-
-	public:
-
-		unsigned iRate() const { return mIRate; }
-		uint32_t cMask() const { return mCMask; }
-		uint32_t stateTable(unsigned g, unsigned i) const { return mStateTable[g][i]; }
-		unsigned deferral() const { return mDeferral; }
-		
-
-		ViterbiR2O4();
-
-		/** Set all cost metrics to zero. */
-		void initializeStates();
-
-		/**
-			Full cycle of the Viterbi algorithm: branch, metrics, prune, select.
-			@return reference to minimum-cost candidate.
-		*/
-		const vCand& step(uint32_t inSample, const float *probs, const float *iprobs);
-
-	private:
-
-		/** Branch survivors into new candidates. */
-		void branchCandidates();
-
-		/** Compute cost metrics for soft-inputs. */
-		void getSoftCostMetrics(uint32_t inSample, const float *probs, const float *iprobs);
-
-		/** Select survivors from the candidate set. */
-		void pruneCandidates();
-
-		/** Find the minimum cost survivor. */
-		const vCand& minCost() const;
-
-		/**
-			Precompute the state tables.
-			@param g Generator index 0..((1/rate)-1)
-		*/
-		void computeStateTables(unsigned g);
-
-		/**
-			Precompute the generator outputs.
-			mCoeffs must be defined first.
-		*/
-		void computeGeneratorTable();
-
-};
-
-
-
-
 class BitVector : public Vector<char> {
 
 
@@ -282,16 +87,6 @@ class BitVector : public Vector<char> {
 
 	void zero() { fill(0); }
 
-	/**@name FEC operations. */
-	//@{
-	/** Calculate the syndrome of the vector with the given Generator. */
-	uint64_t syndrome(Generator& gen) const;
-	/** Calculate the parity word for the vector with the given Generator. */
-	uint64_t parity(Generator& gen) const;
-	/** Encode the signal with the GSM rate 1/2 convolutional encoder. */
-	void encode(const ViterbiR2O4& encoder, BitVector& target);
-	//@}
-
 
 	/** Invert 0<->1. */
 	void invert();
@@ -427,23 +222,20 @@ class SoftVector: public Vector<float> {
 	const SoftVector tail(size_t start) const { return segment(start,size()-start); }
 	//@}
 
-	/** Decode soft symbols with the GSM rate-1/2 Viterbi decoder. */
-	void decode(ViterbiR2O4 &decoder, BitVector& target) const;
-
-	// (pat) How good is the SoftVector in the sense of the bits being solid?
-	// Result of 1 is perfect and 0 means all the bits were 0.5
+	// How good is the SoftVector in the sense of the bits being solid?
+	// Result of 1 is perfect and 0 means all the bits were 0.0
 	// If plow is non-NULL, also return the lowest energy bit.
 	float getEnergy(float *low=0) const;
 
 	/** Fill with "unknown" values. */
-	void unknown() { fill(0.5F); }
+	void unknown() { fill(0.0F); }
 
 	/** Return a hard bit value from a given index by slicing. */
 	bool bit(size_t index) const
 	{
 		const float *dp = mStart+index;
 		assert(dp<mEnd);
-		return (*dp)>0.5F;
+		return (*dp)>0.0F;
 	}
 
 	/** Slice the whole signal into bits. */

CommonLibs/BitVectorTest.cpp

@@ -35,27 +35,6 @@ using namespace std;
 
 int main(int argc, char *argv[])
 {
-	BitVector v1("0000111100111100101011110000");
-	cout << v1 << endl;
-	v1.LSB8MSB();
-	cout << v1 << endl;
-	ViterbiR2O4 vCoder;
-	BitVector v2(v1.size()*2);
-	v1.encode(vCoder,v2);
-	cout << v2 << endl;
-	SoftVector sv2(v2);
-	cout << sv2 << endl;
-	for (unsigned i=0; i<sv2.size()/4; i++) sv2[random()%sv2.size()]=0.5;
-	cout << sv2 << endl;
-	BitVector v3(v1.size());
-	sv2.decode(vCoder,v3);
-	cout << v3 << endl;
-
-	cout << v3.segment(3,4) << endl;
-
-	BitVector v4(v3.segment(0,4),v3.segment(8,4));
-	cout << v4 << endl;
-
 	BitVector v5("000011110000");
 	int r1 = v5.peekField(0,8);
 	int r2 = v5.peekField(4,4);
@@ -70,13 +49,6 @@ int main(int argc, char *argv[])
 	v5.reverse8();
 	cout << v5 << endl;
 
-	BitVector mC = "000000000000111100000000000001110000011100001101000011000000000000000111000011110000100100001010000010100000101000001010000010100000010000000000000000000000000000000000000000000000001100001111000000000000000000000000000000000000000000000000000010010000101000001010000010100000101000001010000001000000000000000000000000110000111100000000000001110000101000001100000001000000000000";
-	SoftVector mCS(mC);
-	BitVector mU(mC.size()/2);
-	mCS.decode(vCoder,mU);
-	cout << "c=" << mCS << endl;
-	cout << "u=" << mU << endl;
-
 
 	unsigned char ts[9] = "abcdefgh";
 	BitVector tp(70);

CommonLibs/Configuration.cpp

@@ -53,6 +53,23 @@ static const char* createConfigTable = {
 	")"
 };
 
+static std::string replaceAll(const std::string input, const std::string search, const std::string replace)
+{
+	std::string output = input;
+	size_t index = 0;
+
+	while (true) {
+		index = output.find(search, index);
+		if (index == std::string::npos) {
+			break;
+		}
+
+		output.replace(index, replace.length(), replace);
+		index += replace.length();
+	}
+
+	return output;
+}
 
 
 float ConfigurationRecord::floatNumber() const
@@ -96,7 +113,7 @@ ConfigurationTable::ConfigurationTable(const char* filename, const char *wCmdNam
 		"Maximum number of alarms to remember inside the application."
 	);
 	mSchema[tmp->getName()] = *tmp;
-	free(tmp);
+	delete tmp;
 
 	tmp = new ConfigurationKey("Log.File","",
 		"",
@@ -110,7 +127,7 @@ ConfigurationTable::ConfigurationTable(const char* filename, const char *wCmdNam
 			"To disable again, execute \"unconfig Log.File\"."
 	);
 	mSchema[tmp->getName()] = *tmp;
-	free(tmp);
+	delete tmp;
 
 	tmp = new ConfigurationKey("Log.Level","NOTICE",
 		"",
@@ -128,7 +145,7 @@ ConfigurationTable::ConfigurationTable(const char* filename, const char *wCmdNam
 		"Default logging level when no other level is defined for a file."
 	);
 	mSchema[tmp->getName()] = *tmp;
-	free(tmp);
+	delete tmp;
 
 	// Add application specific schema
 	mSchema.insert(wSchema.begin(), wSchema.end());
@@ -259,8 +276,8 @@ string ConfigurationTable::getTeX(const std::string& program, const std::string&
 	ss << "% END AUTO-GENERATED CONTENT" << endl;
 	ss << endl;
 
-	string tmp = Utils::replaceAll(ss.str(), "^", "\\^");
-	return Utils::replaceAll(tmp, "_", "\\_");
+	string tmp = replaceAll(ss.str(), "^", "\\^");
+	return replaceAll(tmp, "_", "\\_");
 }
 
 bool ConfigurationTable::defines(const string& key)

CommonLibs/ConfigurationTest.cpp

@@ -47,7 +47,7 @@ int main(int argc, char *argv[])
 
 	gConfig.setUpdateHook(purgeConfig);
 
-	char *keys[5] = {"key1", "key2", "key3", "key4", "key5"};
+	const char *keys[5] = {"key1", "key2", "key3", "key4", "key5"};
 
 	for (int i=0; i<5; i++) {
 		gConfig.set(keys[i],i);

CommonLibs/F16.h

@@ -1,210 +0,0 @@
-/*
-* Copyright 2009 Free Software Foundation, Inc.
-*
-* This software is distributed under the terms of the GNU Affero Public License.
-* See the COPYING file in the main directory for details.
-*
-* This use of this software may be subject to additional restrictions.
-* See the LEGAL file in the main directory for details.
-
-	This program is free software: you can redistribute it and/or modify
-	it under the terms of the GNU Affero General Public License as published by
-	the Free Software Foundation, either version 3 of the License, or
-	(at your option) any later version.
-
-	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 Affero General Public License for more details.
-
-	You should have received a copy of the GNU Affero General Public License
-	along with this program.  If not, see <http://www.gnu.org/licenses/>.
-
-*/
-
-
-#ifndef F16_H
-#define F16_H
-
-#include <stdint.h>
-#include <ostream>
-
-
-
-/** Round a float to the appropriate F16 value. */
-inline int32_t _f16_round(float f)
-{
-	if (f>0.0F) return (int32_t)(f+0.5F);
-	if (f<0.0F) return (int32_t)(f-0.5F);
-	return 0;
-}
-
-
-
-/** A class for F15.16 fixed point arithmetic with saturation.  */
-class F16 {
-
-
-	private:
-
-	int32_t mV;
-
-
-	public:
-
-	F16() {}
-
-	F16(int i) { mV = i<<16; }
-	F16(float f) { mV = _f16_round(f*65536.0F); }
-	F16(double f) { mV = _f16_round((float)f*65536.0F); }
-
-	int32_t& raw() { return mV; }
-	const int32_t& raw() const { return mV; }
-
-	float f() const { return mV/65536.0F; }
-
-	//operator float() const { return mV/65536.0F; }
-	//operator int() const { return mV>>16; }
-
-	F16 operator=(float f)
-	{
-		mV = _f16_round(f*65536.0F);
-		return *this;
-	}
-
-	F16 operator=(int i)
-	{
-		mV = i<<16;
-		return *this;
-	}
-
-	F16 operator=(const F16& other)
-	{
-		mV = other.mV;
-		return mV;
-	}
-
-	F16 operator+(const F16& other) const
-	{
-		F16 retVal;
-		retVal.mV = mV + other.mV;
-		return retVal;
-	}
-
-	F16& operator+=(const F16& other)
-	{
-		mV += other.mV;
-		return *this;
-	}
-
-	F16 operator-(const F16& other) const
-	{
-		F16 retVal;
-		retVal.mV = mV - other.mV;
-		return retVal;
-	}
-
-	F16& operator-=(const F16& other)
-	{
-		mV -= other.mV;
-		return *this;
-	}
-
-	F16 operator*(const F16& other) const
-	{
-		F16 retVal;
-		int64_t p = (int64_t)mV * (int64_t)other.mV;
-		retVal.mV = p>>16;
-		return retVal;
-	}
-
-	F16& operator*=(const F16& other)
-	{
-		int64_t p = (int64_t)mV * (int64_t)other.mV;
-		mV = p>>16;
-		return *this;
-	}
-
-	F16 operator*(float f) const
-	{
-		F16 retVal;
-		retVal.mV = mV * f;
-		return retVal;
-	}
-
-	F16& operator*=(float f)
-	{
-		mV *= f;
-		return *this;
-	}
-
-	F16 operator/(const F16& other) const
-	{
-		F16 retVal;
-		int64_t pV = (int64_t)mV << 16;
-		retVal.mV = pV / other.mV;
-		return retVal;
-	}
-
-	F16& operator/=(const F16& other)
-	{
-		int64_t pV = (int64_t)mV << 16;
-		mV = pV / other.mV;
-		return *this;
-	}
-
-	F16 operator/(float f) const
-	{
-		F16 retVal;
-		retVal.mV = mV / f;
-		return retVal;
-	}
-
-	F16& operator/=(float f)
-	{
-		mV /= f;
-		return *this;
-	}
-
-	bool operator>(const F16& other) const
-	{
-		return mV>other.mV;
-	}
-
-	bool operator<(const F16& other) const
-	{
-		return mV<other.mV;
-	}
-
-	bool operator==(const F16& other) const
-	{
-		return mV==other.mV;
-	}
-
-	bool operator>(float f) const
-	{
-		return (mV/65536.0F) > f;
-	}
-
-	bool operator<(float f) const
-	{
-		return (mV/65536.0F) < f;
-	}
-
-	bool operator==(float f) const
-	{
-		return (mV/65536.0F) == f;
-	}
-
-};
-
-
-
-inline std::ostream& operator<<(std::ostream& os, const F16& v)
-{
-	os << v.f();
-	return os;
-}
-
-#endif
-

CommonLibs/F16Test.cpp

@@ -1,55 +0,0 @@
-/*
-* Copyright 2009 Free Software Foundation, Inc.
-*
-*
-* This software is distributed under the terms of the GNU Affero Public License.
-* See the COPYING file in the main directory for details.
-*
-* This use of this software may be subject to additional restrictions.
-* See the LEGAL file in the main directory for details.
-
-	This program is free software: you can redistribute it and/or modify
-	it under the terms of the GNU Affero General Public License as published by
-	the Free Software Foundation, either version 3 of the License, or
-	(at your option) any later version.
-
-	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 Affero General Public License for more details.
-
-	You should have received a copy of the GNU Affero General Public License
-	along with this program.  If not, see <http://www.gnu.org/licenses/>.
-
-*/
-
-#include "F16.h"
-
-
-#include <iostream>
-
-using namespace std;
-
-int main(int argc, char **argv)
-{
-
-	F16 a = 2.5;
-	F16 b = 1.5;
-	F16 c = 2.5 * 1.5;
-	F16 d = c + a;
-	F16 e = 10;
-	cout << a << ' ' << b << ' ' << c << ' ' << d << ' ' << e << endl;
-
-	a *= 3;
-	b *= 0.3;
-	c *= e;
-	cout << a << ' ' << b << ' ' << c << ' ' << d << endl;
-
-	a /= 3;
-	b /= 0.3;
-	c = d * 0.05;
-	cout << a << ' ' << b << ' ' << c << ' ' << d << endl;
-
-	F16 f = a/d;
-	cout << f << ' ' << f+0.5 << endl;
-}

CommonLibs/Logger.cpp

@@ -30,6 +30,7 @@
 #include <fstream>
 #include <string>
 #include <stdarg.h>
+#include <sys/time.h>	// For gettimeofday
 
 #include "Configuration.h"
 #include "Logger.h"
@@ -111,6 +112,31 @@ int lookupLevel(const string& key)
 	return level;
 }
 
+static std::string format(const char *fmt, ...)
+{
+	va_list ap;
+	char buf[300];
+	va_start(ap,fmt);
+	int n = vsnprintf(buf,300,fmt,ap);
+	va_end(ap);
+	if (n >= (300-4)) { strcpy(&buf[(300-4)],"..."); }
+	return std::string(buf);
+}
+
+const std::string timestr()
+{
+	struct timeval tv;
+	struct tm tm;
+	gettimeofday(&tv,NULL);
+	localtime_r(&tv.tv_sec,&tm);
+	unsigned tenths = tv.tv_usec / 100000;	// Rounding down is ok.
+	return format(" %02d:%02d:%02d.%1d",tm.tm_hour,tm.tm_min,tm.tm_sec,tenths);
+}
+
+std::ostream& operator<<(std::ostream& os, std::ostringstream& ss)
+{
+	return os << ss.str();
+}
 
 int getLoggingLevel(const char* filename)
 {

CommonLibs/Logger.h

@@ -83,7 +83,6 @@
 
 
 #include "Threads.h"		// must be after defines above, if these files are to be allowed to use LOG()
-#include "Utils.h"
 
 /**
 	A C++ stream-based thread-safe logger.
@@ -123,6 +122,8 @@ extern bool gLogToSyslog;	// Output log messages to syslog
 
 std::list<std::string> gGetLoggerAlarms();		///< Get a copy of the recent alarm list.
 
+const std::string timestr();		// A timestamp to print in messages.
+std::ostream& operator<<(std::ostream& os, std::ostringstream& ss);
 
 /**@ Global control and initialization of the logging system. */
 //@{

CommonLibs/Makefile.am

@@ -36,49 +36,39 @@ libcommon_la_SOURCES = \
 	Sockets.cpp \
 	Threads.cpp \
 	Timeval.cpp \
-	Reporting.cpp \
 	Logger.cpp \
 	Configuration.cpp \
-	sqlite3util.cpp \
-	URLEncode.cpp \
-	Utils.cpp
+	sqlite3util.cpp
 
 noinst_PROGRAMS = \
 	BitVectorTest \
+	PRBSTest \
 	InterthreadTest \
 	SocketsTest \
 	TimevalTest \
-	RegexpTest \
 	VectorTest \
 	ConfigurationTest \
-	LogTest \
-	URLEncodeTest \
-	F16Test
+	LogTest
 
 #	ReportingTest 
 
 noinst_HEADERS = \
 	BitVector.h \
+	PRBS.h \
 	Interthread.h \
 	LinkedLists.h \
 	Sockets.h \
 	Threads.h \
 	Timeval.h \
-	Regexp.h \
 	Vector.h \
 	Configuration.h \
-	Reporting.h \
-	F16.h \
-	URLEncode.h \
-	Utils.h \
 	Logger.h \
 	sqlite3util.h
 
-URLEncodeTest_SOURCES = URLEncodeTest.cpp
-URLEncodeTest_LDADD = libcommon.la
-
 BitVectorTest_SOURCES = BitVectorTest.cpp
-BitVectorTest_LDADD = libcommon.la $(SQLITE_LA)
+BitVectorTest_LDADD = libcommon.la $(SQLITE3_LIBS)
+
+PRBSTest_SOURCES = PRBSTest.cpp
 
 InterthreadTest_SOURCES = InterthreadTest.cpp
 InterthreadTest_LDADD = libcommon.la
@@ -92,21 +82,16 @@ TimevalTest_SOURCES = TimevalTest.cpp
 TimevalTest_LDADD = libcommon.la
 
 VectorTest_SOURCES = VectorTest.cpp
-VectorTest_LDADD = libcommon.la $(SQLITE_LA)
-
-RegexpTest_SOURCES = RegexpTest.cpp
-RegexpTest_LDADD = libcommon.la
+VectorTest_LDADD = libcommon.la $(SQLITE3_LIBS)
 
 ConfigurationTest_SOURCES = ConfigurationTest.cpp
-ConfigurationTest_LDADD = libcommon.la 	$(SQLITE_LA)
+ConfigurationTest_LDADD = libcommon.la 	$(SQLITE3_LIBS)
 
 # ReportingTest_SOURCES = ReportingTest.cpp
 # ReportingTest_LDADD = libcommon.la $(SQLITE_LA)
 
 LogTest_SOURCES = LogTest.cpp
-LogTest_LDADD = libcommon.la $(SQLITE_LA)
-
-F16Test_SOURCES = F16Test.cpp
+LogTest_LDADD = libcommon.la $(SQLITE3_LIBS)
 
 MOSTLYCLEANFILES += testSource testDestination
 

CommonLibs/MemoryLeak.h

@@ -1,111 +0,0 @@
-/*
-* Copyright 2011 Range Networks, Inc.
-* All Rights Reserved.
-*
-* This software is distributed under multiple licenses;
-* see the COPYING file in the main directory for licensing
-* information for this specific distribuion.
-*
-* This use of this software may be subject to additional restrictions.
-* See the LEGAL file in the main directory for details.
-
-    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.
-*/
-#ifndef _MEMORYLEAK_
-#define _MEMORYLEAK_ 1
-#include <map>
-#include "ScalarTypes.h"
-#include "Logger.h"
-
-namespace Utils {
-
-struct MemStats {
-	// Enumerates the classes that are checked.
-	// Redundancies are ok, for example, we check BitVector and also
-	// several descendants of BitVector.
-	enum MemoryNames {
-		mZeroIsUnused,
-		mVector,
-		mVectorData,
-		mBitVector,
-		mByteVector,
-		mByteVectorData,
-		mRLCRawBlock,
-		mRLCUplinkDataBlock,
-		mRLCMessage,
-		mRLCMsgPacketDownlinkDummyControlBlock,	// Redundant with RLCMessage
-		mTBF,
-		mLlcEngine,
-		mSgsnDownlinkMsg,
-		mRachInfo,
-		mPdpPdu,
-		mFECDispatchInfo,
-		mL3Frame,
-		msignalVector,
-		mSoftVector,
-		mScramblingCode,
-		mURlcDownSdu,
-		mURlcPdu,
-		// Must be last:
-		mMax,
-	};
-	int mMemTotal[mMax];	// In elements, not bytes.
-	int mMemNow[mMax];
-	const char *mMemName[mMax];
-	MemStats();
-	void memChkNew(MemoryNames memIndex, const char *id);
-	void memChkDel(MemoryNames memIndex, const char *id);
-	void text(std::ostream &os);
-	// We would prefer to use an unordered_map, but that requires special compile switches.
-	// What a super great language.
-	typedef std::map<std::string,Int_z> MemMapType;
-	MemMapType mMemMap;
-};
-extern struct MemStats gMemStats;
-extern int gMemLeakDebug;
-
-// This is a memory leak detector.
-// Use by putting RN_MEMCHKNEW and RN_MEMCHKDEL in class constructors/destructors,
-// or use the DEFINE_MEMORY_LEAK_DETECTOR class and add the defined class
-// as an ancestor to the class to be memory leak checked.
-
-struct MemLabel {
-	std::string mccKey;
-	virtual ~MemLabel() {
-		Int_z &tmp = Utils::gMemStats.mMemMap[mccKey]; tmp = tmp - 1;
-	}
-};
-
-#if RN_DISABLE_MEMORY_LEAK_TEST
-#define RN_MEMCHKNEW(type)
-#define RN_MEMCHKDEL(type)
-#define RN_MEMLOG(type,ptr)
-#define DEFINE_MEMORY_LEAK_DETECTOR_CLASS(subClass,checkerClass) \
-	struct checkerClass {};
-#else
-
-#define RN_MEMCHKNEW(type) { Utils::gMemStats.memChkNew(Utils::MemStats::m##type,#type); }
-#define RN_MEMCHKDEL(type) { Utils::gMemStats.memChkDel(Utils::MemStats::m##type,#type); }
-
-#define RN_MEMLOG(type,ptr) { \
-	static std::string key = format("%s_%s:%d",#type,__FILE__,__LINE__); \
-	(ptr)->/* MemCheck##type:: */ mccKey = key; \
-	Utils::gMemStats.mMemMap[key]++; \
-	}
-
-// TODO: The above assumes that checkclass is MemCheck ## subClass
-#define DEFINE_MEMORY_LEAK_DETECTOR_CLASS(subClass,checkerClass) \
-	struct checkerClass : public virtual Utils::MemLabel { \
-	    checkerClass() { RN_MEMCHKNEW(subClass); } \
-		virtual ~checkerClass() { \
-			RN_MEMCHKDEL(subClass); \
-		} \
-	};
-
-#endif
-
-}	// namespace Utils
-
-#endif

CommonLibs/PRBS.h

@@ -0,0 +1,110 @@
+/*
+ * Copyright (C) 2017 Alexander Chemeris <Alexander.Chemeris@fairwaves.co>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#ifndef PRBS_H
+#define PRBS_H
+
+#include <stdint.h>
+#include <assert.h>
+
+/** Pseudo-random binary sequence (PRBS) generator (a Galois LFSR implementation). */
+class PRBS {
+public:
+
+  PRBS(unsigned wLen, uint64_t wCoeff, uint64_t wState = 0x01)
+    : mCoeff(wCoeff), mStartState(wState), mState(wState), mLen(wLen)
+  { assert(wLen<=64); }
+
+  /**@name Accessors */
+  //@{
+  uint64_t coeff() const { return mCoeff; }
+  uint64_t state() const { return mState; }
+  void state(uint64_t state) { mState = state & mask(); }
+  unsigned size() const { return mLen; }
+  //@}
+
+  /**
+    Calculate one bit of a PRBS
+  */
+  unsigned generateBit()
+  {
+    const unsigned result = mState & 0x01;
+    processBit(result);
+    return result;
+  }
+
+  /**
+    Update the generator state by one bit.
+    If you want to synchronize your PRBS to a known state, call this function
+    size() times passing your PRBS to it bit by bit.
+  */
+  void processBit(unsigned inBit)
+  {
+    mState >>= 1;
+    if (inBit) mState ^= mCoeff;
+  }
+
+  /** Return true when PRBS is wrapping through initial state */
+  bool isFinished() const { return mStartState == mState; }
+
+protected:
+
+  uint64_t mCoeff;      ///< polynomial coefficients. LSB is zero exponent.
+  uint64_t mStartState; ///< initial shift register state.
+  uint64_t mState;      ///< shift register state.
+  unsigned mLen;        ///< number of bits used in shift register
+
+  /** Return mask for the state register */
+  uint64_t mask() const { return (mLen==64)?0xFFFFFFFFFFFFFFFFUL:((1<<mLen)-1); }
+
+};
+
+/**
+  A standard 9-bit based pseudorandom binary sequence (PRBS) generator.
+  Polynomial: x^9 + x^5 + 1
+*/
+class PRBS9 : public PRBS {
+  public:
+  PRBS9(uint64_t wState = 0x01)
+  : PRBS(9, 0x0110, wState)
+  {}
+};
+
+/**
+  A standard 15-bit based pseudorandom binary sequence (PRBS) generator.
+  Polynomial: x^15 + x^14 + 1
+*/
+class PRBS15 : public PRBS {
+public:
+  PRBS15(uint64_t wState = 0x01)
+  : PRBS(15, 0x6000, wState)
+  {}
+};
+
+/**
+  A standard 64-bit based pseudorandom binary sequence (PRBS) generator.
+  Polynomial: x^64 + x^63 + x^61 + x^60 + 1
+*/
+class PRBS64 : public PRBS {
+public:
+  PRBS64(uint64_t wState = 0x01)
+  : PRBS(64, 0xD800000000000000ULL, wState)
+  {}
+};
+
+#endif // PRBS_H

CommonLibs/PRBSTest.cpp

@@ -0,0 +1,42 @@
+/*
+ * Copyright (C) 2017 Alexander Chemeris <Alexander.Chemeris@fairwaves.co>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#include "PRBS.h"
+#include <iostream>
+#include <cstdlib>
+#include <assert.h>
+
+void testPrbs(PRBS &prbs, uint64_t expectedPeriod)
+{
+  uint64_t period = 0;
+  do {
+    std::cout << prbs.generateBit();
+    period++;
+  } while (!prbs.isFinished());
+  std::cout << std::endl;
+  std::cout << "Period: " << period << std::endl;
+  assert(period == expectedPeriod);
+}
+
+int main(int argc, char *argv[])
+{
+  PRBS9 prbs9(0x01);
+  testPrbs(prbs9, (1<<9)-1);
+  PRBS15 prbs15(0x01);
+  testPrbs(prbs15, (1<<15)-1);
+}

CommonLibs/Regexp.h

@@ -1,64 +0,0 @@
-/*
-* Copyright 2008 Free Software Foundation, Inc.
-*
-* This software is distributed under the terms of the GNU Affero Public License.
-* See the COPYING file in the main directory for details.
-*
-* This use of this software may be subject to additional restrictions.
-* See the LEGAL file in the main directory for details.
-
-	This program is free software: you can redistribute it and/or modify
-	it under the terms of the GNU Affero General Public License as published by
-	the Free Software Foundation, either version 3 of the License, or
-	(at your option) any later version.
-
-	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 Affero General Public License for more details.
-
-	You should have received a copy of the GNU Affero General Public License
-	along with this program.  If not, see <http://www.gnu.org/licenses/>.
-
-*/
-
-
-#ifndef REGEXPW_H
-#define REGEXPW_H
-
-#include <regex.h>
-#include <iostream>
-#include <stdlib.h>
-
-
-
-class Regexp {
-
-	private:
-
-	regex_t mRegex;
-
-
-	public:
-
-	Regexp(const char* regexp, int flags=REG_EXTENDED)
-	{
-		int result = regcomp(&mRegex, regexp, flags);
-		if (result) {
-			char msg[256];
-			regerror(result,&mRegex,msg,255);
-			std::cerr << "Regexp compilation of " << regexp << " failed: " << msg << std::endl;
-			abort();
-		}
-	}
-
-	~Regexp()
-		{ regfree(&mRegex); }
-
-	bool match(const char *text, int flags=0) const
-		{ return regexec(&mRegex, text, 0, NULL, flags)==0; }
-
-};
-
-
-#endif

CommonLibs/RegexpTest.cpp

@@ -1,48 +0,0 @@
-/*
-* Copyright 2008 Free Software Foundation, Inc.
-*
-*
-* This software is distributed under the terms of the GNU Affero Public License.
-* See the COPYING file in the main directory for details.
-*
-* This use of this software may be subject to additional restrictions.
-* See the LEGAL file in the main directory for details.
-
-	This program is free software: you can redistribute it and/or modify
-	it under the terms of the GNU Affero General Public License as published by
-	the Free Software Foundation, either version 3 of the License, or
-	(at your option) any later version.
-
-	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 Affero General Public License for more details.
-
-	You should have received a copy of the GNU Affero General Public License
-	along with this program.  If not, see <http://www.gnu.org/licenses/>.
-
-*/
-
-
-
-#include "Regexp.h"
-#include <iostream>
-
-using namespace std;
-
-
-int main(int argc, char *argv[])
-{
-
-	Regexp email("^[[:graph:]]+@[[:graph:]]+ ");
-	Regexp simple("^dburgess@");
-
-	const char text1[] = "dburgess@jcis.net test message";
-	const char text2[] = "no address text message";
-
-	cout << email.match(text1) << " " << text1 << endl;
-	cout << email.match(text2) << " " << text2 << endl;
-
-	cout << simple.match(text1) << " " << text1 << endl;
-	cout << simple.match(text2) << " " << text2 << endl;
-}

CommonLibs/Reporting.cpp

@@ -1,145 +0,0 @@
-/**@file Module for performance-reporting mechanisms. */
-/*
-* Copyright 2012 Range Networks, Inc.
-*
-* This software is distributed under the terms of the GNU Affero Public License.
-* See the COPYING file in the main directory for details.
-*
-* This use of this software may be subject to additional restrictions.
-* See the LEGAL file in the main directory for details.
-
-	This program is free software: you can redistribute it and/or modify
-	it under the terms of the GNU Affero General Public License as published by
-	the Free Software Foundation, either version 3 of the License, or
-	(at your option) any later version.
-
-	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 Affero General Public License for more details.
-
-	You should have received a copy of the GNU Affero General Public License
-	along with this program.  If not, see <http://www.gnu.org/licenses/>.
-
-*/
-
-#include "Reporting.h"
-#include "Logger.h"
-#include <stdio.h>
-#include <string.h>
-
-static const char* createReportingTable = {
-	"CREATE TABLE IF NOT EXISTS REPORTING ("
-		"NAME TEXT UNIQUE NOT NULL, "
-		"VALUE INTEGER DEFAULT 0, "
-		"CLEAREDTIME INTEGER NOT NULL, "
-		"UPDATETIME INTEGER DEFAULT 0 "
-	")"
-};
-
-
-ReportingTable::ReportingTable(const char* filename)
-{
-	gLogEarly(LOG_INFO | mFacility, "opening reporting table from path %s", filename);
-	// Connect to the database.
-	int rc = sqlite3_open(filename,&mDB);
-	if (rc) {
-		gLogEarly(LOG_EMERG | mFacility, "cannot open reporting database at %s, error message: %s", filename, sqlite3_errmsg(mDB));
-		sqlite3_close(mDB);
-		mDB = NULL;
-		return;
-	}
-	// Create the table, if needed.
-	if (!sqlite3_command(mDB,createReportingTable)) {
-		gLogEarly(LOG_EMERG | mFacility, "cannot create reporting table in database at %s, error message: %s", filename, sqlite3_errmsg(mDB));
-	}
-}
-
-
-bool ReportingTable::create(const char* paramName)
-{
-	char cmd[200];
-	sprintf(cmd,"INSERT OR IGNORE INTO REPORTING (NAME,CLEAREDTIME) VALUES (\"%s\",%ld)", paramName, time(NULL));
-	if (!sqlite3_command(mDB,cmd)) {
-		gLogEarly(LOG_CRIT|mFacility, "cannot create reporting parameter %s, error message: %s", paramName, sqlite3_errmsg(mDB));
-		return false;
-	}
-	return true;
-}
-
-
-
-bool ReportingTable::incr(const char* paramName)
-{
-	char cmd[200];
-	sprintf(cmd,"UPDATE REPORTING SET VALUE=VALUE+1, UPDATETIME=%ld WHERE NAME=\"%s\"", time(NULL), paramName);
-	if (!sqlite3_command(mDB,cmd)) {
-		gLogEarly(LOG_CRIT|mFacility, "cannot increment reporting parameter %s, error message: %s", paramName, sqlite3_errmsg(mDB));
-		return false;
-	}
-	return true;
-}
-
-
-
-bool ReportingTable::max(const char* paramName, unsigned newVal)
-{
-	char cmd[200];
-	sprintf(cmd,"UPDATE REPORTING SET VALUE=MAX(VALUE,%u), UPDATETIME=%ld WHERE NAME=\"%s\"", newVal, time(NULL), paramName);
-	if (!sqlite3_command(mDB,cmd)) {
-		gLogEarly(LOG_CRIT|mFacility, "cannot maximize reporting parameter %s, error message: %s", paramName, sqlite3_errmsg(mDB));
-		return false;
-	}
-	return true;
-}
-
-
-bool ReportingTable::clear(const char* paramName)
-{
-	char cmd[200];
-	sprintf(cmd,"UPDATE REPORTING SET VALUE=0, UPDATETIME=0, CLEAREDTIME=%ld WHERE NAME=\"%s\"", time(NULL), paramName);
-	if (!sqlite3_command(mDB,cmd)) {
-		gLogEarly(LOG_CRIT|mFacility, "cannot clear reporting parameter %s, error message: %s", paramName, sqlite3_errmsg(mDB));
-		return false;
-	}
-	return true;
-}
-
-
-bool ReportingTable::create(const char* baseName, unsigned minIndex, unsigned maxIndex)
-{
-	size_t sz = strlen(baseName);
-	for (unsigned i = minIndex; i<=maxIndex; i++) {
-		char name[sz+10];
-		sprintf(name,"%s.%u",baseName,i);
-		if (!create(name)) return false;
-	}
-	return true;
-}
-
-bool ReportingTable::incr(const char* baseName, unsigned index)
-{
-	char name[strlen(baseName)+10];
-	sprintf(name,"%s.%u",baseName,index);
-	return incr(name);
-}
-
-
-bool ReportingTable::max(const char* baseName, unsigned index, unsigned newVal)
-{
-	char name[strlen(baseName)+10];
-	sprintf(name,"%s.%u",baseName,index);
-	return max(name,newVal);
-}
-
-
-bool ReportingTable::clear(const char* baseName, unsigned index)
-{
-	char name[strlen(baseName)+10];
-	sprintf(name,"%s.%u",baseName,index);
-	return clear(name);
-}
-
-
-
-

CommonLibs/Reporting.h

@@ -1,86 +0,0 @@
-/**@file Module for performance-reporting mechanisms. */
-/*
-* Copyright 2012 Range Networks, Inc.
-*
-* This software is distributed under the terms of the GNU Affero Public License.
-* See the COPYING file in the main directory for details.
-*
-* This use of this software may be subject to additional restrictions.
-* See the LEGAL file in the main directory for details.
-
-	This program is free software: you can redistribute it and/or modify
-	it under the terms of the GNU Affero General Public License as published by
-	the Free Software Foundation, either version 3 of the License, or
-	(at your option) any later version.
-
-	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 Affero General Public License for more details.
-
-	You should have received a copy of the GNU Affero General Public License
-	along with this program.  If not, see <http://www.gnu.org/licenses/>.
-
-*/
-
-#ifndef REPORTING_H
-#define REPORTING_H
-
-#include <sqlite3util.h>
-#include <ostream>
-
-
-/**
-	Collect performance statistics into a database.
-	Parameters are counters or max/min trackers, all integer.
-*/
-class ReportingTable {
-
-	private:
-
-	sqlite3* mDB;				///< database connection
-	int mFacility;				///< rsyslogd facility
-
-
-
-	public:
-
-	/**
-		Open the database connection;
-		create the table if it does not exist yet.
-	*/
-	ReportingTable(const char* filename);
-
-	/** Create a new parameter. */
-	bool create(const char* paramName);
-
-	/** Create an indexed parameter set. */
-	bool create(const char* baseBame, unsigned minIndex, unsigned maxIndex);
-
-	/** Increment a counter. */
-	bool incr(const char* paramName);
-
-	/** Increment an indexed counter. */
-	bool incr(const char* baseName, unsigned index);
-
-	/** Take a max of a parameter. */
-	bool max(const char* paramName, unsigned newVal);
-
-	/** Take a max of an indexed parameter. */
-	bool max(const char* paramName, unsigned index, unsigned newVal);
-
-	/** Clear a value.  */
-	bool clear(const char* paramName);
-
-	/** Clear an indexed value.  */
-	bool clear(const char* paramName, unsigned index);
-
-	/** Dump the database to a stream. */
-	void dump(std::ostream&) const;
-
-};
-
-#endif
-
-
-// vim: ts=4 sw=4

CommonLibs/ScalarTypes.h

@@ -1,136 +0,0 @@
-/*
-* Copyright 2011 Range Networks, Inc.
-* All Rights Reserved.
-*
-* This software is distributed under multiple licenses;
-* see the COPYING file in the main directory for licensing
-* information for this specific distribuion.
-*
-* This use of this software may be subject to additional restrictions.
-* See the LEGAL file in the main directory for details.
-
-    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.
-*/
-
-#ifndef SCALARTYPES_H
-#define SCALARTYPES_H
-#include <iostream>	// For size_t
-#include <stdint.h>
-//#include "GSMCommon.h"	// Was included for Z100Timer
-
-// We dont bother to define *= /= etc.; you'll have to convert: a*=b; to: a=a*b;
-#define _INITIALIZED_SCALAR_BASE_FUNCS(Classname,Basetype,Init) \
-	Classname() : value(Init) {} \
-	Classname(Basetype wvalue) { value = wvalue; } /* Can set from basetype. */ \
-	operator Basetype(void) const { return value; }		/* Converts from basetype. */ \
-	Basetype operator=(Basetype wvalue) { return value = wvalue; } \
-	Basetype* operator&() { return &value; }
-
-#define _INITIALIZED_SCALAR_ARITH_FUNCS(Basetype) \
-	Basetype operator++() { return ++value; } \
-	Basetype operator++(int) { return value++; } \
-	Basetype operator--() { return --value; } \
-	Basetype operator--(int) { return value--; } \
-	Basetype operator+=(Basetype wvalue) { return value = value + wvalue; } \
-	Basetype operator-=(Basetype wvalue) { return value = value - wvalue; }
-
-#define _INITIALIZED_SCALAR_FUNCS(Classname,Basetype,Init) \
-	_INITIALIZED_SCALAR_BASE_FUNCS(Classname,Basetype,Init) \
-	_INITIALIZED_SCALAR_ARITH_FUNCS(Basetype)
-
-
-#define _DECLARE_SCALAR_TYPE(Classname_i,Classname_z,Basetype) \
-	template <Basetype Init> \
-	struct Classname_i { \
-		Basetype value; \
-		_INITIALIZED_SCALAR_FUNCS(Classname_i,Basetype,Init) \
-	}; \
-	typedef Classname_i<0> Classname_z;
-
-
-// Usage:
-// Where 'classname' is one of the types listed below, then:
-// 		classname_z specifies a zero initialized type;
-// 		classname_i<value> initializes the type to the specified value.
-// We also define Float_z.
-_DECLARE_SCALAR_TYPE(Int_i, 	Int_z,  	int)
-_DECLARE_SCALAR_TYPE(Char_i,	Char_z, 	signed char)
-_DECLARE_SCALAR_TYPE(Int16_i,	Int16_z,	int16_t)
-_DECLARE_SCALAR_TYPE(Int32_i,	Int32_z,	int32_t)
-_DECLARE_SCALAR_TYPE(UInt_i,  	UInt_z,  	unsigned)
-_DECLARE_SCALAR_TYPE(UChar_i,  	UChar_z,  	unsigned char)
-_DECLARE_SCALAR_TYPE(UInt16_i,	UInt16_z,	uint16_t)
-_DECLARE_SCALAR_TYPE(UInt32_i,	UInt32_z,	uint32_t)
-_DECLARE_SCALAR_TYPE(Size_t_i,	Size_t_z,	size_t)
-
-// Bool is special because it cannot accept some arithmetic funcs
-//_DECLARE_SCALAR_TYPE(Bool_i,  	Bool_z, 	bool)
-template <bool Init>
-struct Bool_i {
-	bool value;
-	_INITIALIZED_SCALAR_BASE_FUNCS(Bool_i,bool,Init)
-};
-typedef Bool_i<0> Bool_z;
-
-// float is special, because C++ does not permit the template initalization:
-struct Float_z {
-	float value;
-	_INITIALIZED_SCALAR_FUNCS(Float_z,float,0)
-};
-struct Double_z {
-	double value;
-	_INITIALIZED_SCALAR_FUNCS(Double_z,double,0)
-};
-
-
-class ItemWithValueAndWidth {
-	public:
-	virtual unsigned getValue() const = 0;
-	virtual unsigned getWidth() const = 0;
-};
-
-// A Range Networks Field with a specified width.
-// See RLCMessages.h for examples.
-template <int Width=32, unsigned Init=0>
-class Field_i : public ItemWithValueAndWidth
-{
-	public:
-	unsigned value;
-	_INITIALIZED_SCALAR_FUNCS(Field_i,unsigned,Init)
-	unsigned getWidth() const { return Width; }
-	unsigned getValue() const { return value; }
-};
-
-// Synonym for Field_i, but no way to do it.
-template <int Width, unsigned Init=0>
-class Field_z : public ItemWithValueAndWidth
-{
-	public:
-	unsigned value;
-	_INITIALIZED_SCALAR_FUNCS(Field_z,unsigned,Init)
-	unsigned getWidth() const { return Width; }
-	unsigned getValue() const { return value; }
-};
-
-// This is an uninitialized field.
-template <int Width=32, unsigned Init=0>
-class Field : public ItemWithValueAndWidth
-{
-	public:
-	unsigned value;
-	_INITIALIZED_SCALAR_FUNCS(Field,unsigned,Init)
-	unsigned getWidth() const { return Width; }
-	unsigned getValue() const { return value; }
-};
-
-
-// A Z100Timer with an initial value specified.
-//template <int Init>
-//class Z100Timer_i : public GSM::Z100Timer {
-//	public:
-//	Z100Timer_i() : GSM::Z100Timer(Init) {}
-//};
-
-#endif

CommonLibs/URLEncode.cpp

@@ -1,28 +0,0 @@
-/* Copyright 2011, Range Networks, Inc. */
-
-#include <URLEncode.h>
-#include <string>
-#include <string.h>
-#include <ctype.h>
-
-using namespace std;
-
-//based on javascript encodeURIComponent()
-string URLEncode(const string &c)
-{
-	static const char *digits = "01234567890ABCDEF";
-	string retVal="";
-	for (size_t i=0; i<c.length(); i++)
-	{
-		const char ch = c[i];
-		if (isalnum(ch) || strchr("-_.!~'()",ch)) {
-			retVal += ch;
-		} else {
-			retVal += '%';
-			retVal += digits[(ch>>4) & 0x0f];
-			retVal += digits[ch & 0x0f];
-		}
-	}
-	return retVal;
-}
-

CommonLibs/URLEncode.h

@@ -1,30 +0,0 @@
-/*
-* Copyright 2011 Free Software Foundation, Inc.
-*
-*
-* This software is distributed under the terms of the GNU Affero Public License.
-* See the COPYING file in the main directory for details.
-*
-* This use of this software may be subject to additional restrictions.
-* See the LEGAL file in the main directory for details.
-
-	This program is free software: you can redistribute it and/or modify
-	it under the terms of the GNU Affero General Public License as published by
-	the Free Software Foundation, either version 3 of the License, or
-	(at your option) any later version.
-
-	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 Affero General Public License for more details.
-
-	You should have received a copy of the GNU Affero General Public License
-	along with this program.  If not, see <http://www.gnu.org/licenses/>.
-
-*/
-
-
-
-# include <string>
-
-std::string URLEncode(const std::string&);

CommonLibs/URLEncodeTest.cpp

@@ -1,17 +0,0 @@
-
-#include "URLEncode.h"
-#include <string>
-#include <iostream>
-
-
-using namespace std;
-
-
-int main(int argc, char *argv[])
-{
-
-	string test = string("Testing: !@#$%^&*() " __DATE__ " " __TIME__);
-	cout << test << endl;
-	cout << URLEncode(test) << endl;
-}
-

CommonLibs/Utils.cpp

@@ -1,211 +0,0 @@
-/*
-* Copyright 2011 Range Networks, Inc.
-* All Rights Reserved.
-*
-* This software is distributed under multiple licenses;
-* see the COPYING file in the main directory for licensing
-* information for this specific distribuion.
-*
-* This use of this software may be subject to additional restrictions.
-* See the LEGAL file in the main directory for details.
-
-    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.
-*/
-
-#include <unistd.h>		// For usleep
-#include <sys/time.h>	// For gettimeofday
-#include <stdio.h>		// For vsnprintf
-#include <ostream>		// For ostream
-#include <sstream>		// For ostringstream
-#include <string.h>		// For strcpy
-//#include "GSMCommon.h"
-#include "Utils.h"
-#include "MemoryLeak.h"
-
-namespace Utils {
-
-MemStats gMemStats;
-int gMemLeakDebug = 0;
-
-MemStats::MemStats()
-{
-	memset(mMemNow,0,sizeof(mMemNow));
-	memset(mMemTotal,0,sizeof(mMemTotal));
-	memset(mMemName,0,sizeof(mMemName));
-}
-
-void MemStats::text(std::ostream &os)
-{
-	os << "Structs current total:\n";
-	for (int i = 0; i < mMax; i++) {
-		os << "\t" << (mMemName[i] ? mMemName[i] : "unknown") << " " << mMemNow[i] << " " << mMemTotal[i] << "\n";
-	}
-}
-
-void MemStats::memChkNew(MemoryNames memIndex, const char *id)
-{
-	/*std::cout << "new " #type "\n";*/
-	mMemNow[memIndex]++;
-	mMemTotal[memIndex]++;
-	mMemName[memIndex] = id;
-}
-
-void MemStats::memChkDel(MemoryNames memIndex, const char *id)
-{
-	/*std::cout << "del " #type "\n";*/
-	mMemNow[memIndex]--;
-	if (mMemNow[memIndex] < 0) {
-		LOG(ERR) << "Memory underflow on type "<<id;
-		if (gMemLeakDebug) assert(0);
-		mMemNow[memIndex] += 100;	// Prevent another message for a while.
-	}
-}
-
-std::ostream& operator<<(std::ostream& os, std::ostringstream& ss)
-{
-	return os << ss.str();
-}
-
-std::ostream &osprintf(std::ostream &os, const char *fmt, ...)
-{
-	va_list ap;
-	char buf[300];
-	va_start(ap,fmt);
-	int n = vsnprintf(buf,300,fmt,ap);
-	va_end(ap);
-	if (n >= (300-4)) { strcpy(&buf[(300-4)],"..."); }
-	os << buf;
-	return os;
-}
-
-std::string format(const char *fmt, ...)
-{
-	va_list ap;
-	char buf[300];
-	va_start(ap,fmt);
-	int n = vsnprintf(buf,300,fmt,ap);
-	va_end(ap);
-	if (n >= (300-4)) { strcpy(&buf[(300-4)],"..."); }
-	return std::string(buf);
-}
-
-// Return time in seconds with high resolution.
-// Note: In the past I found this to be a surprisingly expensive system call in linux.
-double timef()
-{
-	struct timeval tv;
-	gettimeofday(&tv,NULL);
-	return tv.tv_usec / 1000000.0 + tv.tv_sec;
-}
-
-const std::string timestr()
-{
-	struct timeval tv;
-	struct tm tm;
-	gettimeofday(&tv,NULL);
-	localtime_r(&tv.tv_sec,&tm);
-	unsigned tenths = tv.tv_usec / 100000;	// Rounding down is ok.
-	return format(" %02d:%02d:%02d.%1d",tm.tm_hour,tm.tm_min,tm.tm_sec,tenths);
-}
-
-// High resolution sleep for the specified time.
-// Return FALSE if time is already past.
-void sleepf(double howlong)
-{
-	if (howlong <= 0.00001) return;		// Less than 10 usecs, forget it.
-	usleep((useconds_t) (1000000.0 * howlong));
-}
-
-//bool sleepuntil(double untilwhen)
-//{
-	//double now = timef();
-	//double howlong = untilwhen - now;		// Fractional time in seconds.
-	// We are not worrying about overflow because all times should be in the near future.
-	//if (howlong <= 0.00001) return false;		// Less than 10 usecs, forget it.
-	//sleepf(sleeptime);
-//}
-
-std::string Text2Str::str() const
-{
-	std::ostringstream ss;
-	text(ss);
-	return ss.str();
-}
-
-std::ostream& operator<<(std::ostream& os, const Text2Str *val)
-{
-	std::ostringstream ss;
-	if (val) {
-		val->text(ss);
-		os << ss.str(); 
-	} else {
-		os << "(null)";
-	}
-	return os;
-}
-
-// Greatest Common Denominator.
-// This is by Doug Brown.
-int gcd(int x, int y)
-{
-	if (x > y) {
-		return x % y == 0 ? y : gcd(y, x % y);
-	} else {
-		return y % x == 0 ? x : gcd(x, y % x);
-	}
-}
-
-
-// Split a C string into an argc,argv array in place; the input string is modified.
-// Returns argc, and places results in argv, up to maxargc elements.
-// The final argv receives the rest of the input string from maxargc on,
-// even if it contains additional splitchars.
-// The correct idiom for use is to make a copy of your string, like this:
-// char *copy = strcpy((char*)alloca(the_string.length()+1),the_string.c_str());
-// char *argv[2];
-// int argc = cstrSplit(copy,argv,2,NULL);
-// If you want to detect the error of too many arguments, add 1 to argv, like this:
-// char *argv[3];
-// int argc = cstrSplit(copy,argv,3,NULL);
-// if (argc == 3) { error("too many arguments"; }
-int cstrSplit(char *in, char **pargv,int maxargc, const char *splitchars)
-{
-	if (splitchars == NULL) { splitchars = " \t\r\n"; }	// Default is any space.
-	int argc = 0;
-	while (argc < maxargc) {
-		while (*in && strchr(splitchars,*in)) {in++;}	// scan past any splitchars
-		if (! *in) return argc;					// return if finished.
-		pargv[argc++] = in;						// save ptr to start of arg.
-		in = strpbrk(in,splitchars);			// go to end of arg.
-		if (!in) return	argc;					// return if finished.
-		*in++ = 0;								// zero terminate this arg.
-	}
-	return argc;
-}
-
-std::ostream& operator<<(std::ostream& os, const Statistic<int> &stat) { stat.text(os); return os; }
-std::ostream& operator<<(std::ostream& os, const Statistic<unsigned> &stat) { stat.text(os); return os; }
-std::ostream& operator<<(std::ostream& os, const Statistic<float> &stat) { stat.text(os); return os; }
-std::ostream& operator<<(std::ostream& os, const Statistic<double> &stat) { stat.text(os); return os; }
-
-std::string replaceAll(const std::string input, const std::string search, const std::string replace)
-{
-	std::string output = input;
- 	int index = 0;
-
-	while (true) {
-		index = output.find(search, index);
-		if (index == std::string::npos) {
-			break;
-		}
-
-		output.replace(index, replace.length(), replace);
-		index += replace.length();
-	}
-
-	return output;
-}
-
-};

CommonLibs/Utils.h

@@ -1,148 +0,0 @@
-/*
-* Copyright 2011 Range Networks, Inc.
-* All Rights Reserved.
-*
-* This software is distributed under multiple licenses;
-* see the COPYING file in the main directory for licensing
-* information for this specific distribuion.
-*
-* This use of this software may be subject to additional restrictions.
-* See the LEGAL file in the main directory for details.
-
-    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.
-*/
-
-#ifndef GPRSUTILS_H
-#define GPRSUTILS_H
-#include <stdint.h>
-#include <stdarg.h>
-#include <string>
-#include <string.h>
-#include <math.h>		// for sqrtf
-#include "Logger.h"
-
-
-namespace Utils {
-
-extern double timef();					// high resolution time
-extern const std::string timestr();		// A timestamp to print in messages.
-extern void sleepf(double howlong);	// high resolution sleep
-extern int gcd(int x, int y);
-
-// It is irritating to create a string just to interface to the brain-damaged
-// C++ stream class, but this is only used for debug messages.
-std::string format(const char *fmt, ...) __attribute__((format (printf,1,2)));
-
-int cstrSplit(char *in, char **pargv,int maxargc, const char *splitchars=NULL);
-
-// For classes with a text() function, provide a function to return a String,
-// and also a standard << stream function that takes a pointer to the object.
-// We dont provide the function that takes a reference to the object
-// because it is too highly overloaded and generally doesnt work.
-class Text2Str {
-	public:
-	virtual void text(std::ostream &os) const = 0;
-	std::string str() const;
-};
-std::ostream& operator<<(std::ostream& os, const Text2Str *val);
-
-#if 0
-// Generic Activity Timer.  Lots of controls to make everybody happy.
-class ATimer {
-	double mStart;
-	//bool mActive;
-	double mLimitTime;
-	public:
-	ATimer() : mStart(0), mLimitTime(0) { }
-	ATimer(double wLimitTime) : mStart(0), mLimitTime(wLimitTime) { }
-	void start() { mStart=timef(); }
-	void stop() { mStart=0; }
-	bool active() { return !!mStart; }
-	double elapsed() { return timef() - mStart; }
-	bool expired() { return elapsed() > mLimitTime; }
-};
-#endif
-
-
-struct BitSet {
-	unsigned mBits;
-	void setBit(unsigned whichbit) { mBits |= 1<<whichbit; }
-	void clearBit(unsigned whichbit) { mBits &= ~(1<<whichbit); }
-	unsigned getBit(unsigned whichbit) const { return mBits & (1<<whichbit); }
-	bool isSet(unsigned whichbit) const { return mBits & (1<<whichbit); }
-	unsigned bits() const { return mBits; }
-	operator int(void) const { return mBits; }
-	BitSet() { mBits = 0; }
-};
-
-// Store current, min, max and compute running average and standard deviation.
-template<class Type> struct Statistic {
-	Type mCurrent, mMin, mMax;		// min,max optional initialization so you can print before adding any values.
-	unsigned mCnt;
-	double mSum;
-	//double mSum2;	// sum of squares.
-	// (Type) cast needed in case Type is an enum, stupid language.
-	Statistic() : mCurrent((Type)0), mMin((Type)0), mMax((Type)0), mCnt(0), mSum(0) /*,mSum2(0)*/ {}
-	// Set the current value and add a statisical point.
-	void addPoint(Type val) {
-		mCurrent = val;
-		if (mCnt == 0 || val < mMin) {mMin = val;}
-		if (mCnt == 0 || val > mMax) {mMax = val;}
-		mCnt++;
-		mSum += val;
-		//mSum2 += val * val;
-	}
-	Type getCurrent() const {	// Return current value.
-		return mCnt ? mCurrent : 0;
-	}
-	double getAvg() const { 			// Return average.
-		return mCnt==0 ? 0 : mSum/mCnt; 
-	};
-	//float getSD() const { 	// Return standard deviation.  Use low precision square root function.
-	//	return mCnt==0 ? 0 : sqrtf(mCnt * mSum2 - mSum*mSum) / mCnt;
-	//}
-
-	void text(std::ostream &os) const {	// Print everything in parens.
-		os << "("<<mCurrent;
-		if (mMin != mMax) {	// Not point in printing all this stuff if min == max.
-			os <<LOGVAR2("min",mMin)<<LOGVAR2("max",mMax)<<LOGVAR2("avg",getAvg());
-			if (mCnt <= 999999) {
-				os <<LOGVAR2("N",mCnt);
-			} else { // Shorten this up:
-				char buf[10], *ep;
-				sprintf(buf,"%.3g",round(mCnt));
-				if ((ep = strchr(buf,'e')) && ep[1] == '+') { strcpy(ep+1,ep+2); }
-				os << LOGVAR2("N",buf);
-			}
-			// os<<LOGVAR2("sd",getSD())  standard deviation not interesting
-		}
-		os << ")";
-		// " min="<<mMin <<" max="<<mMax <<format(" avg=%4g sd=%3g)",getAvg(),getSD());
-	}
-	// Not sure if this works:
-	//std::string statStr() const {
-	//	return (std::string)mCurrent + " min=" + (std::string) mMin +" max="+(string)mMax+ format(" avg=%4g sd=%3g",getAvg(),getSD());
-	//}
-};
-
-// This I/O mechanism is so dumb:
-std::ostream& operator<<(std::ostream& os, const Statistic<int> &stat);
-std::ostream& operator<<(std::ostream& os, const Statistic<unsigned> &stat);
-std::ostream& operator<<(std::ostream& os, const Statistic<float> &stat);
-std::ostream& operator<<(std::ostream& os, const Statistic<double> &stat);
-
-
-// Yes, they botched and left this out:
-std::ostream& operator<<(std::ostream& os, std::ostringstream& ss);
-
-std::ostream &osprintf(std::ostream &os, const char *fmt, ...) __attribute__((format (printf,2,3)));
-
-std::string replaceAll(const std::string input, const std::string search, const std::string replace);
-
-};	// namespace
-
-using namespace Utils;
-
-#endif

CommonLibs/Vector.h

@@ -92,6 +92,13 @@ template <class T> class Vector {
 		mEnd = mStart + newSize;
 	}
 
+	/** Reduce addressable size of the Vector, keeping content. */
+	void shrink(size_t newSize)
+	{
+		assert(newSize <= mEnd - mStart);
+		mEnd = mStart + newSize;
+	}
+
 	/** Release memory and clear pointers. */
 	void clear() { resize(0); }
 
@@ -222,6 +229,21 @@ template <class T> class Vector {
 		memcpy(other.mStart,base,span*sizeof(T));
 	}
 
+	/**
+		Move (copy) a segment of this vector into a different position in the vector
+		@param from Start point from which to copy.
+		@param to   Start point to which to copy.
+		@param span The number of elements to copy.
+	*/
+	void segmentMove(size_t from, size_t to, size_t span)
+	{
+		const T* baseFrom = mStart + from;
+		T* baseTo = mStart + to;
+		assert(baseFrom+span<=mEnd);
+		assert(baseTo+span<=mEnd);
+		memmove(baseTo,baseFrom,span*sizeof(T));
+	}
+
 	void fill(const T& val)
 	{
 		T* dp=mStart;

CommonLibs/sqlite3util.cpp

@@ -4,7 +4,7 @@
 */
 
 
-#include "sqlite3.h"
+#include <sqlite3.h>
 #include "sqlite3util.h"
 
 #include <string.h>

Makefile.am

@@ -21,14 +21,13 @@
 include $(top_srcdir)/Makefile.common
 
 ACLOCAL_AMFLAGS = -I config
-AM_CPPFLAGS = $(STD_DEFINES_AND_INCLUDES) $(USB_INCLUDES) $(WITH_INCLUDES)
+AM_CPPFLAGS = $(STD_DEFINES_AND_INCLUDES) $(USB_INCLUDES) $(WITH_INCLUDES) $(SQLITE3_CFLAGS)
 AM_CXXFLAGS = -Wall -pthread -ldl
 #AM_CXXFLAGS = -Wall -O2 -NDEBUG -pthread -ldl
 #AM_CFLAGS = -Wall -O2 -NDEBUG -pthread -ldl
 
 # Order must be preserved
 SUBDIRS = \
-	sqlite3 \
 	CommonLibs \
 	GSM \
 	Transceiver52M

Makefile.common

@@ -23,16 +23,13 @@ top_builddir = $(abs_top_builddir)
 
 COMMON_INCLUDEDIR = $(top_srcdir)/CommonLibs
 GSM_INCLUDEDIR = $(top_srcdir)/GSM
-SQLITE_INCLUDEDIR = $(top_srcdir)/sqlite3
 
 STD_DEFINES_AND_INCLUDES = \
 	$(SVNDEV) \
 	-I$(COMMON_INCLUDEDIR) \
-	-I$(GSM_INCLUDEDIR) \
-	-I$(SQLITE_INCLUDEDIR)
+	-I$(GSM_INCLUDEDIR)
 
 COMMON_LA = $(top_builddir)/CommonLibs/libcommon.la
 GSM_LA = $(top_builddir)/GSM/libGSM.la
-SQLITE_LA = $(top_builddir)/sqlite3/libsqlite.la -ldl
 
 MOSTLYCLEANFILES = *~

Transceiver52M/Channelizer.cpp

@@ -0,0 +1,108 @@
+/*
+ * Polyphase channelizer
+ * 
+ * Copyright (C) 2012-2014 Tom Tsou <tom@tsou.cc>
+ * Copyright (C) 2015 Ettus Research LLC
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * 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 Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ * See the COPYING file in the main directory for details.
+ */
+
+#include <stdlib.h>
+#include <math.h>
+#include <assert.h>
+#include <string.h>
+#include <cstdio>
+
+#include "Logger.h"
+#include "Channelizer.h"
+
+extern "C" {
+#include "common/fft.h"
+#include "common/convolve.h"
+}
+
+static void deinterleave(const float *in, size_t ilen,
+			 float **out, size_t olen, size_t m)
+{
+	size_t i, n;
+
+	for (i = 0; i < olen; i++) {
+		for (n = 0; n < m; n++) {
+			out[m - 1 - n][2 * i + 0] = in[2 * (i * m + n) + 0];
+			out[m - 1 - n][2 * i + 1] = in[2 * (i * m + n) + 1];
+		}
+	}
+}
+
+size_t Channelizer::inputLen() const
+{
+	return blockLen * m;
+}
+
+size_t Channelizer::outputLen() const
+{
+	return blockLen;
+}
+
+float *Channelizer::outputBuffer(size_t chan) const
+{
+	if (chan >= m)
+		return NULL;
+
+	return hInputs[chan];
+}
+
+/* 
+ * Implementation based on material found in:
+ *
+ * "harris, fred, Multirate Signal Processing, Upper Saddle River, NJ,
+ *     Prentice Hall, 2006."
+ */
+bool Channelizer::rotate(const float *in, size_t len)
+{
+	size_t hSize = 2 * hLen * sizeof(float);
+
+	if (!checkLen(blockLen, len))
+		return false;
+
+	deinterleave(in, len, hInputs, blockLen, m);
+
+	/* 
+	 * Convolve through filterbank while applying and saving sample history 
+	 */
+	for (size_t i = 0; i < m; i++) {
+		memcpy(&hInputs[i][2 * -hLen], hist[i], hSize);
+		memcpy(hist[i], &hInputs[i][2 * (blockLen - hLen)], hSize);
+
+		convolve_real(hInputs[i], blockLen,
+			      subFilters[i], hLen,
+			      hOutputs[i], blockLen,
+			      0, blockLen, 1, 0);
+	}
+
+	cxvec_fft(fftHandle);
+
+	return true;
+}
+
+/* Setup channelizer paramaters */
+Channelizer::Channelizer(size_t m, size_t blockLen, size_t hLen)
+	: ChannelizerBase(m, blockLen, hLen)
+{
+}
+
+Channelizer::~Channelizer()
+{
+}

Transceiver52M/Channelizer.h

@@ -0,0 +1,34 @@
+#ifndef _CHANNELIZER_RX_H_
+#define _CHANNELIZER_RX_H_
+
+#include "ChannelizerBase.h"
+
+class Channelizer : public ChannelizerBase {
+public:
+	/** Constructor for channelizing filter bank
+	    @param m number of physical channels
+	    @param blockLen number of samples per output of each iteration
+	    @param hLen number of taps in each constituent filter path
+	*/
+	Channelizer(size_t m, size_t blockLen, size_t hLen = 16);
+	~Channelizer();
+
+	/* Return required input and output buffer lengths */
+	size_t inputLen() const;
+	size_t outputLen() const;
+
+	/** Rotate "input commutator" and drive samples through filterbank
+	    @param in complex input vector 
+	    @param iLen number of samples in buffer (must match block length)
+	    @return false on error and true otherwise
+	*/
+	bool rotate(const float *in, size_t iLen);
+
+	/** Get buffer for an output path
+	    @param chan channel number of filterbank
+            @return NULL on error and pointer to buffer otherwise
+	*/
+	float *outputBuffer(size_t chan) const;
+};
+
+#endif /* _CHANNELIZER_RX_H_ */

Transceiver52M/ChannelizerBase.cpp

@@ -0,0 +1,251 @@
+/*
+ * Polyphase channelizer
+ * 
+ * Copyright (C) 2012-2014 Tom Tsou <tom@tsou.cc>
+ * Copyright (C) 2015 Ettus Research LLC 
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * 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 Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ * See the COPYING file in the main directory for details.
+ */
+
+#include <malloc.h>
+#include <math.h>
+#include <assert.h>
+#include <string.h>
+#include <cstdio>
+
+#include "Logger.h"
+#include "ChannelizerBase.h"
+
+extern "C" {
+#include "common/fft.h"
+}
+
+static float sinc(float x)
+{
+	if (x == 0.0f)
+		return 0.999999999999f;
+
+	return sin(M_PI * x) / (M_PI * x);
+}
+
+/*
+ * There are more efficient reversal algorithms, but we only reverse at
+ * initialization so we don't care.
+ */
+static void reverse(float *buf, size_t len)
+{
+	float tmp[2 * len];
+	memcpy(tmp, buf, 2 * len * sizeof(float));
+
+	for (size_t i = 0; i < len; i++) {
+		buf[2 * i + 0] = tmp[2 * (len - 1 - i) + 0];
+		buf[2 * i + 1] = tmp[2 * (len - 1 - i) + 1];
+	}
+}
+
+/* 
+ * Create polyphase filterbank
+ *
+ * Implementation based material found in, 
+ *
+ * "harris, fred, Multirate Signal Processing, Upper Saddle River, NJ,
+ *     Prentice Hall, 2006."
+ */
+bool ChannelizerBase::initFilters()
+{
+	size_t protoLen = m * hLen;
+	float *proto;
+	float sum = 0.0f, scale = 0.0f;
+	float midpt = (float) (protoLen - 1.0) / 2.0;
+
+	/* 
+	 * Allocate 'M' partition filters and the temporary prototype
+	 * filter. Coefficients are real only and must be 16-byte memory
+	 * aligned for SSE usage.
+	 */
+	proto = new float[protoLen];
+	if (!proto)
+		return false;
+
+	subFilters = (float **) malloc(sizeof(float *) * m);
+	if (!subFilters) {
+		delete[] proto;
+		return false;
+	}
+
+	for (size_t i = 0; i < m; i++) {
+		subFilters[i] = (float *)
+				memalign(16, hLen * 2 * sizeof(float));
+	}
+
+	/* 
+	 * Generate the prototype filter with a Blackman-harris window.
+	 * Scale coefficients with DC filter gain set to unity divided
+	 * by the number of channels.
+	 */
+	float a0 = 0.35875;
+	float a1 = 0.48829;
+	float a2 = 0.14128;
+	float a3 = 0.01168;
+
+	for (size_t i = 0; i < protoLen; i++) {
+		proto[i] = sinc(((float) i - midpt) / (float) m);
+		proto[i] *= a0 -
+			    a1 * cos(2 * M_PI * i / (protoLen - 1)) +
+			    a2 * cos(4 * M_PI * i / (protoLen - 1)) -
+			    a3 * cos(6 * M_PI * i / (protoLen - 1));
+		sum += proto[i];
+	}
+	scale = (float) m / sum;
+
+	/* 
+	 * Populate partition filters and reverse the coefficients per
+	 * convolution requirements.
+	 */
+	for (size_t i = 0; i < hLen; i++) {
+		for (size_t n = 0; n < m; n++) {
+			subFilters[n][2 * i + 0] = proto[i * m + n] * scale;
+			subFilters[n][2 * i + 1] = 0.0f;
+		}
+	}
+
+	for (size_t i = 0; i < m; i++)
+		reverse(subFilters[i], hLen);
+
+	delete[] proto;
+
+	return true;
+}
+
+bool ChannelizerBase::initFFT()
+{
+	size_t size;
+
+	if (fftInput || fftOutput || fftHandle)
+		return false;
+
+	size = blockLen * m * 2 * sizeof(float);
+	fftInput = (float *) fft_malloc(size);
+	memset(fftInput, 0, size);
+
+	size = (blockLen + hLen) * m * 2 * sizeof(float);
+	fftOutput = (float *) fft_malloc(size);
+	memset(fftOutput, 0, size);
+
+	if (!fftInput | !fftOutput) {
+		LOG(ALERT) << "Memory allocation error";
+		return false;
+	}
+
+	fftHandle = init_fft(0, m, blockLen, blockLen + hLen,
+			     fftInput, fftOutput, hLen);
+	return true;
+}
+
+bool ChannelizerBase::mapBuffers()
+{
+	if (!fftHandle) {
+		LOG(ALERT) << "FFT buffers not initialized";
+		return false;
+	}
+
+	hInputs = (float **) malloc(sizeof(float *) * m);
+	hOutputs = (float **) malloc(sizeof(float *) * m);
+	if (!hInputs | !hOutputs)
+		return false;
+
+	for (size_t i = 0; i < m; i++) {
+		hInputs[i] = &fftOutput[2 * (i * (blockLen + hLen) + hLen)];
+		hOutputs[i] = &fftInput[2 * (i * blockLen)];
+	}
+
+	return true;
+}
+
+/* 
+ * Setup filterbank internals
+ */
+bool ChannelizerBase::init()
+{
+	/*
+	 * Filterbank coefficients, fft plan, history, and output sample
+	 * rate conversion blocks
+	 */
+	if (!initFilters()) {
+		LOG(ALERT) << "Failed to initialize channelizing filter";
+		return false;
+	}
+
+	hist = (float **) malloc(sizeof(float *) * m);
+	for (size_t i = 0; i < m; i++) {
+		hist[i] = new float[2 * hLen];
+		memset(hist[i], 0, 2 * hLen * sizeof(float));
+	}
+
+	if (!initFFT()) {
+		LOG(ALERT) << "Failed to initialize FFT";
+		return false;
+	}
+
+	mapBuffers();
+
+	return true;
+}
+
+/* Check vector length validity */
+bool ChannelizerBase::checkLen(size_t innerLen, size_t outerLen)
+{
+	if (outerLen != innerLen * m) {
+		LOG(ALERT) << "Invalid outer length " << innerLen
+			   <<  " is not multiple of " << blockLen;
+		return false;
+	}
+
+	if (innerLen != blockLen) {
+		LOG(ALERT) << "Invalid inner length " << outerLen
+			   <<  " does not equal " << blockLen;
+		return false;
+	}
+
+	return true;
+}
+
+/* 
+ * Setup channelizer paramaters
+ */
+ChannelizerBase::ChannelizerBase(size_t m, size_t blockLen, size_t hLen)
+	: fftInput(NULL), fftOutput(NULL), fftHandle(NULL)
+{
+	this->m = m;
+	this->hLen = hLen;
+	this->blockLen = blockLen;
+}
+
+ChannelizerBase::~ChannelizerBase()
+{
+	free_fft(fftHandle);
+
+	for (size_t i = 0; i < m; i++) {
+		free(subFilters[i]);
+		delete hist[i];
+	}
+
+	fft_free(fftInput);
+	fft_free(fftOutput);
+
+	free(hInputs);
+	free(hOutputs);
+	free(hist);
+}

Transceiver52M/ChannelizerBase.h

@@ -0,0 +1,39 @@
+#ifndef _CHANNELIZER_BASE_H_
+#define _CHANNELIZER_BASE_H_
+
+class ChannelizerBase {
+protected:
+	ChannelizerBase(size_t m, size_t blockLen, size_t hLen);
+	~ChannelizerBase();
+
+	/* Channelizer parameters */
+	size_t m;
+	size_t hLen;
+	size_t blockLen;
+
+	/* Channelizer filterbank sub-filters */
+	float **subFilters;
+
+	/* Input/Output buffers */
+	float **hInputs, **hOutputs, **hist;
+	float *fftInput, *fftOutput;
+
+	/* Pointer to opaque FFT instance */
+	struct fft_hdl *fftHandle;
+
+	/* Initializer internals */
+	bool initFilters();
+	bool initFFT();
+	void releaseFilters();
+
+	/* Map overlapped FFT and filter I/O buffers */
+	bool mapBuffers();
+
+	/* Buffer length validity checking */
+	bool checkLen(size_t innerLen, size_t outerLen);
+public:
+	/* Initilize channelizer/synthesis filter internals */
+	bool init();
+};
+
+#endif /* _CHANNELIZER_BASE_H_ */

Transceiver52M/Makefile.am

@@ -54,17 +54,25 @@ COMMON_SOURCES = \
 	radioInterface.cpp \
 	radioVector.cpp \
 	radioClock.cpp \
+	radioBuffer.cpp \
 	sigProcLib.cpp \
 	signalVector.cpp \
-	Transceiver.cpp
+	Transceiver.cpp \
+	ChannelizerBase.cpp \
+	Channelizer.cpp \
+	Synthesis.cpp \
+	common/fft.c
 
 libtransceiver_la_SOURCES = \
 	$(COMMON_SOURCES) \
 	Resampler.cpp \
 	radioInterfaceResamp.cpp \
-	radioInterfaceDiversity.cpp
+	radioInterfaceMulti.cpp
 
-bin_PROGRAMS = osmo-trx
+bin_PROGRAMS = \
+	osmo-trx \
+	osmo-trx-gen \
+	osmo-trx-dec
 
 noinst_HEADERS = \
 	Complex.h \
@@ -72,18 +80,37 @@ noinst_HEADERS = \
 	radioVector.h \
 	radioClock.h \
 	radioDevice.h \
+	radioBuffer.h \
 	sigProcLib.h \
 	signalVector.h \
 	Transceiver.h \
 	USRPDevice.h \
 	Resampler.h \
+	ChannelizerBase.h \
+	Channelizer.h \
+	Synthesis.h \
 	common/convolve.h \
 	common/convert.h \
 	common/scale.h \
-	common/mult.h
+	common/mult.h \
+	common/fft.h
 
 osmo_trx_SOURCES = osmo-trx.cpp
 osmo_trx_LDADD = \
+	libtransceiver.la \
+	$(ARCH_LA) \
+	$(GSM_LA) \
+	$(COMMON_LA) $(SQLITE3_LIBS)
+
+osmo_trx_gen_SOURCES = osmo-trx-gen.cpp
+osmo_trx_gen_LDADD = \
+	libtransceiver.la \
+	$(ARCH_LA) \
+	$(GSM_LA) \
+	$(COMMON_LA) $(SQLITE_LA)
+
+osmo_trx_dec_SOURCES = osmo-trx-dec.cpp
+osmo_trx_dec_LDADD = \
 	libtransceiver.la \
 	$(ARCH_LA) \
 	$(GSM_LA) \
@@ -94,5 +121,5 @@ libtransceiver_la_SOURCES += USRPDevice.cpp
 osmo_trx_LDADD += $(USRP_LIBS)
 else
 libtransceiver_la_SOURCES += UHDDevice.cpp
-osmo_trx_LDADD += $(UHD_LIBS)
+osmo_trx_LDADD += $(UHD_LIBS) $(FFTWF_LIBS)
 endif

Transceiver52M/Resampler.cpp

@@ -61,7 +61,7 @@ bool Resampler::initFilters(float bw)
 
 	partitions = (float **) malloc(sizeof(float *) * p);
 	if (!partitions) {
-		free(proto);
+		delete[] proto;
 		return false;
 	}
 
@@ -112,7 +112,7 @@ bool Resampler::initFilters(float bw)
 		}
 	}
 
-	delete proto;
+	delete[] proto;
 
 	return true;
 }
@@ -167,22 +167,13 @@ void Resampler::computePath()
 	}
 }
 
-int Resampler::rotate(float *in, size_t in_len, float *out, size_t out_len)
+int Resampler::rotate(const float *in, size_t in_len, float *out, size_t out_len)
 {
 	int n, path;
-	int hist_len = filt_len - 1;
 
 	if (!check_vec_len(in_len, out_len, p, q))
 		return -1;
 
-	if (history_on) {
-		memcpy(&in[-2 * hist_len],
-		       history, hist_len * 2 * sizeof(float));
-	} else {
-		memset(&in[-2 * hist_len], 0,
-		       hist_len * 2 * sizeof(float));
-	}
-
 	/* Generate output from precomputed input/output paths */
 	for (size_t i = 0; i < out_len; i++) {
 		n = in_index[i]; 
@@ -194,27 +185,15 @@ int Resampler::rotate(float *in, size_t in_len, float *out, size_t out_len)
 			      n, 1, 1, 0);
 	}
 
-	/* Save history */
-	if (history_on) {
-		memcpy(history, &in[2 * (in_len - hist_len)],
-		       hist_len * 2 * sizeof(float));
-	}
-
 	return out_len;
 }
 
 bool Resampler::init(float bw)
 {
-	size_t hist_len = filt_len - 1;
-
 	/* Filterbank filter internals */
-	if (initFilters(bw) < 0)
+	if (!initFilters(bw))
 		return false;
 
-	/* History buffer */
-	history = new float[2 * hist_len];
-	memset(history, 0, 2 * hist_len * sizeof(float));
-
 	/* Precompute filterbank paths */
 	in_index = new size_t[MAX_OUTPUT_LEN];
 	out_path = new size_t[MAX_OUTPUT_LEN];
@@ -228,14 +207,8 @@ size_t Resampler::len()
 	return filt_len;
 }
 
-void Resampler::enableHistory(bool on)
-{
-	history_on = on;
-}
-
 Resampler::Resampler(size_t p, size_t q, size_t filt_len)
-	: in_index(NULL), out_path(NULL), partitions(NULL),
-	  history(NULL), history_on(true)
+	: in_index(NULL), out_path(NULL), partitions(NULL)
 {
 	this->p = p;
 	this->q = q;
@@ -246,7 +219,6 @@ Resampler::~Resampler()
 {
 	releaseFilters();
 
-	delete history;
 	delete in_index;
 	delete out_path;
 }

Transceiver52M/Resampler.h

@@ -52,18 +52,13 @@ public:
 	 * Input and output vector lengths must of be equal multiples of the
 	 * rational conversion rate denominator and numerator respectively.
 	 */
-	int rotate(float *in, size_t in_len, float *out, size_t out_len);
+	int rotate(const float *in, size_t in_len, float *out, size_t out_len);
 
 	/* Get filter length
 	 *   @return number of taps in each filter partition 
 	 */
 	size_t len();
 
-	/*
-	 * Enable/disable history 
-	 */
-	void enableHistory(bool on);
-
 private:
 	size_t p;
 	size_t q;
@@ -72,8 +67,6 @@ private:
 	size_t *out_path;
 
 	float **partitions;
-	float *history;
-	bool history_on;
 
 	bool initFilters(float bw);
 	void releaseFilters();

Transceiver52M/Synthesis.cpp

@@ -0,0 +1,121 @@
+/*
+ * Polyphase synthesis filter
+ * 
+ * Copyright (C) 2012-2014 Tom Tsou <tom@tsou.cc>
+ * Copyright (C) 2015 Ettus Research LLC
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * 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 Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ * See the COPYING file in the main directory for details.
+ */
+
+#include <stdlib.h>
+#include <math.h>
+#include <assert.h>
+#include <string.h>
+#include <cstdio>
+
+#include "Logger.h"
+#include "Synthesis.h"
+
+extern "C" {
+#include "common/fft.h"
+#include "common/convolve.h"
+}
+
+static void interleave(float **in, size_t ilen,
+		       float *out, size_t m)
+{
+	size_t i, n;
+
+	for (i = 0; i < ilen; i++) {
+		for (n = 0; n < m; n++) {
+			out[2 * (i * m + n) + 0] = in[n][2 * i + 0];
+			out[2 * (i * m + n) + 1] = in[n][2 * i + 1];
+		}
+	}
+}
+
+size_t Synthesis::inputLen() const
+{
+	return blockLen;
+}
+
+size_t Synthesis::outputLen() const
+{
+	return blockLen * m;
+}
+
+float *Synthesis::inputBuffer(size_t chan) const
+{
+	if (chan >= m)
+		return NULL;
+
+	return hOutputs[chan];
+}
+
+bool Synthesis::resetBuffer(size_t chan)
+{
+	if (chan >= m)
+		return false;
+
+	memset(hOutputs[chan], 0, blockLen * 2 * sizeof(float));
+
+	return true;
+}
+
+/* 
+ * Implementation based on material found in:
+ *
+ * "harris, fred, Multirate Signal Processing, Upper Saddle River, NJ,
+ *     Prentice Hall, 2006."
+ */
+bool Synthesis::rotate(float *out, size_t len)
+{
+	size_t hSize = 2 * hLen * sizeof(float);
+
+	if (!checkLen(blockLen, len)) {
+		std::cout << "Length fail" << std::endl;
+		exit(1);
+		return false;
+	}
+
+	cxvec_fft(fftHandle);
+
+	/* 
+	 * Convolve through filterbank while applying and saving sample history 
+	 */
+	for (size_t i = 0; i < m; i++) {
+		memcpy(&hInputs[i][2 * -hLen], hist[i], hSize);
+		memcpy(hist[i], &hInputs[i][2 * (blockLen - hLen)], hSize);
+
+		convolve_real(hInputs[i], blockLen,
+			      subFilters[i], hLen,
+			      hOutputs[i], blockLen,
+			      0, blockLen, 1, 0);
+	}
+
+	/* Interleave into output vector */
+	interleave(hOutputs, blockLen, out, m);
+
+	return true;
+}
+
+Synthesis::Synthesis(size_t m, size_t blockLen, size_t hLen)
+	: ChannelizerBase(m, blockLen, hLen)
+{
+}
+
+Synthesis::~Synthesis()
+{
+}

Transceiver52M/Synthesis.h

@@ -0,0 +1,35 @@
+#ifndef _SYNTHESIS_H_
+#define _SYNTHESIS_H_
+
+#include "ChannelizerBase.h"
+
+class Synthesis : public ChannelizerBase {
+public:
+	/** Constructor for synthesis filterbank
+	    @param m number of physical channels
+	    @param blockLen number of samples per output of each iteration
+	    @param hLen number of taps in each constituent filter path
+	*/
+	Synthesis(size_t m, size_t blockLen, size_t hLen = 16);
+	~Synthesis();
+
+	/* Return required input and output buffer lengths */
+	size_t inputLen() const;
+	size_t outputLen() const;
+
+	/** Rotate "output commutator" and drive samples through filterbank
+	    @param out complex output vector 
+	    @param oLen number of samples in buffer (must match block length * m)
+	    @return false on error and true otherwise
+	*/
+	bool rotate(float *out, size_t oLen);
+
+	/** Get buffer for an input path
+	    @param chan channel number of filterbank
+            @return NULL on error and pointer to buffer otherwise
+	*/
+	float *inputBuffer(size_t chan) const;
+	bool resetBuffer(size_t chan);
+};
+
+#endif /* _SYNTHESIS_H_ */

Transceiver52M/Transceiver.cpp

@@ -85,7 +85,7 @@ bool TransceiverState::init(int filler, size_t sps, float scale, size_t rtsc, un
         burst = generateDummyBurst(sps, n);
         break;
       case Transceiver::FILLER_NORM_RAND:
-        burst = genRandNormalBurst(rtsc, sps, n);
+        burst = genRandNormalBurst(rtsc, sps, n, mPrbs);
         break;
       case Transceiver::FILLER_EDGE_RAND:
         burst = generateEdgeBurst(rtsc);
@@ -104,7 +104,7 @@ bool TransceiverState::init(int filler, size_t sps, float scale, size_t rtsc, un
 
     if ((filler == Transceiver::FILLER_NORM_RAND) ||
         (filler == Transceiver::FILLER_EDGE_RAND)) {
-        chanType[n] = Transceiver::TSC;
+        chanType[n] = TSC;
     }
   }
 
@@ -121,8 +121,8 @@ Transceiver::Transceiver(int wBasePort,
     mClockSocket(wBasePort, wTRXAddress, mBasePort + 100),
     mTransmitLatency(wTransmitLatency), mRadioInterface(wRadioInterface),
     rssiOffset(wRssiOffset),
-    mSPSTx(tx_sps), mSPSRx(rx_sps), mChans(chans), mOn(false),
-    mTxFreq(0.0), mRxFreq(0.0), mTSC(0), mMaxExpectedDelayAB(2*rx_sps), mMaxExpectedDelayNB(2*rx_sps),
+    mSPSTx(tx_sps), mSPSRx(rx_sps), mChans(chans), mEdge(false), mOn(false),
+    mTxFreq(0.0), mRxFreq(0.0), mTSC(0), mMaxExpectedDelayAB(0), mMaxExpectedDelayNB(0),
     mWriteBurstToDiskMask(0)
 {
   txFullScale = mRadioInterface->fullScaleInputValue();
@@ -160,7 +160,7 @@ Transceiver::~Transceiver()
  * are still expected to report clock indications through control channel
  * activity.
  */
-bool Transceiver::init(int filler, size_t rtsc, unsigned rach_delay)
+bool Transceiver::init(int filler, size_t rtsc, unsigned rach_delay, bool edge)
 {
   int d_srcport, d_dstport, c_srcport, c_dstport;
 
@@ -174,6 +174,8 @@ bool Transceiver::init(int filler, size_t rtsc, unsigned rach_delay)
     return false;
   }
 
+  mEdge = edge;
+
   mDataSockets.resize(mChans);
   mCtrlSockets.resize(mChans);
   mControlServiceLoopThreads.resize(mChans);
@@ -441,8 +443,8 @@ void Transceiver::setModulus(size_t timeslot, size_t chan)
 }
 
 
-Transceiver::CorrType Transceiver::expectedCorrType(GSM::Time currTime,
-                                                    size_t chan)
+CorrType Transceiver::expectedCorrType(GSM::Time currTime,
+                                       size_t chan)
 {
   static int tchh_subslot[26] = { 0,1,0,1,0,1,0,1,0,1,0,1,0,0,1,0,1,0,1,0,1,0,1,0,1,1 };
   static int sdcch4_subslot[102] = { 3,3,3,3,0,0,2,2,2,2,3,3,3,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0,2,2,2,2,
@@ -531,51 +533,6 @@ Transceiver::CorrType Transceiver::expectedCorrType(GSM::Time currTime,
   }
 }
 
-int Transceiver::detectBurst(signalVector &burst,
-                             complex &amp, float &toa, CorrType type)
-{
-  float threshold = 5.0, rc = 0;
-
-  switch (type) {
-  case EDGE:
-    rc = detectEdgeBurst(burst, mTSC, threshold, mSPSRx,
-                         amp, toa, mMaxExpectedDelayNB);
-    if (rc > 0)
-      break;
-    else
-      type = TSC;
-  case TSC:
-    rc = analyzeTrafficBurst(burst, mTSC, threshold, mSPSRx,
-                             amp, toa, mMaxExpectedDelayNB);
-    break;
-  case RACH:
-    threshold = 6.0;
-    rc = detectRACHBurst(burst, threshold, mSPSRx, amp, toa,
-                         mMaxExpectedDelayAB);
-    break;
-  default:
-    LOG(ERR) << "Invalid correlation type";
-  }
-
-  if (rc > 0)
-    return type;
-
-  return rc;
-}
-
-
-/*
- * Demodulate GMSK by direct rotation and soft slicing.
- */
-SoftVector *Transceiver::demodulate(signalVector &burst, complex amp,
-                                    float toa, CorrType type)
-{
-  if (type == EDGE)
-	  return demodEdgeBurst(burst, mSPSRx, amp, toa);
-
-  return demodulateBurst(burst, mSPSRx, amp, toa);
-}
-
 void writeToFile(radioVector *radio_burst, size_t chan)
 {
   GSM::Time time = radio_burst->getTime();
@@ -596,7 +553,7 @@ SoftVector *Transceiver::pullRadioVector(GSM::Time &wTime, double &RSSI, bool &i
 {
   int rc;
   complex amp;
-  float toa, pow, max = -1.0, avg = 0.0;
+  float toa, max = -1.0, avg = 0.0;
   int max_i = -1;
   signalVector *burst;
   SoftVector *bits = NULL;
@@ -612,6 +569,10 @@ SoftVector *Transceiver::pullRadioVector(GSM::Time &wTime, double &RSSI, bool &i
   GSM::Time time = radio_burst->getTime();
   CorrType type = expectedCorrType(time, chan);
 
+  /* Enable 8-PSK burst detection if EDGE is enabled */
+  if (mEdge && (type == TSC))
+    type = EDGE;
+
   /* Debug: dump bursts to disk */
   /* bits 0-7  - chan 0 timeslots
    * bits 8-15 - chan 1 timeslots */
@@ -627,7 +588,7 @@ SoftVector *Transceiver::pullRadioVector(GSM::Time &wTime, double &RSSI, bool &i
 
   /* Select the diversity channel with highest energy */
   for (size_t i = 0; i < radio_burst->chans(); i++) {
-    energyDetect(*radio_burst->getVector(i), 20 * mSPSRx, 0.0, &pow);
+    float pow = energyDetect(*radio_burst->getVector(i), 20 * mSPSRx);
     if (pow > max) {
       max = pow;
       max_i = i;
@@ -646,7 +607,7 @@ SoftVector *Transceiver::pullRadioVector(GSM::Time &wTime, double &RSSI, bool &i
   avg = sqrt(avg / radio_burst->chans());
 
   wTime = time;
-  RSSI = 20.0 * log10(rxFullScale / avg);
+  RSSI = 20.0 * log10(avg / rxFullScale);
 
   /* RSSI estimation are valid */
   isRssiValid = true;
@@ -665,7 +626,8 @@ SoftVector *Transceiver::pullRadioVector(GSM::Time &wTime, double &RSSI, bool &i
   }
 
   /* Detect normal or RACH bursts */
-  rc = detectBurst(*burst, amp, toa, type);
+  rc = detectAnyBurst(*burst, mTSC, BURST_THRESH, mSPSRx, type, amp, toa,
+                      (type==RACH)?mMaxExpectedDelayAB:mMaxExpectedDelayNB);
 
   if (rc > 0) {
     type = (CorrType) rc;
@@ -680,9 +642,9 @@ SoftVector *Transceiver::pullRadioVector(GSM::Time &wTime, double &RSSI, bool &i
     return NULL;
   }
 
-  timingOffset = toa / mSPSRx;
+  timingOffset = toa;
 
-  bits = demodulate(*burst, amp, toa, type);
+  bits = demodAnyBurst(*burst, mSPSRx, amp, toa, type);
 
   delete radio_burst;
   return bits;
@@ -730,27 +692,26 @@ void Transceiver::driveControl(size_t chan)
     sprintf(response,"RSP POWEROFF 0");
   }
   else if (strcmp(command,"POWERON")==0) {
-    if (!start())
+    if (!start()) {
       sprintf(response,"RSP POWERON 1");
-    else
+    } else {
       sprintf(response,"RSP POWERON 0");
       for (int i = 0; i < 8; i++) {
         for (int j = 0; j < 8; j++)
           mHandover[i][j] = false;
       }
+    }
   }
   else if (strcmp(command,"HANDOVER")==0){
     int ts=0,ss=0;
     sscanf(buffer,"%3s %s %d %d",cmdcheck,command,&ts,&ss);
     mHandover[ts][ss] = true;
-    LOG(WARNING) << "HANDOVER RACH at timeslot " << ts << " subslot " << ss;
     sprintf(response,"RSP HANDOVER 0 %d %d",ts,ss);
   }
   else if (strcmp(command,"NOHANDOVER")==0){
     int ts=0,ss=0;
     sscanf(buffer,"%3s %s %d %d",cmdcheck,command,&ts,&ss);
     mHandover[ts][ss] = false;
-    LOG(WARNING) << "NOHANDOVER at timeslot " << ts << " subslot " << ss;
     sprintf(response,"RSP NOHANDOVER 0 %d %d",ts,ss);
   }
   else if (strcmp(command,"SETMAXDLY")==0) {
@@ -827,11 +788,10 @@ void Transceiver::driveControl(size_t chan)
     // set TSC
     unsigned TSC;
     sscanf(buffer, "%3s %s %d", cmdcheck, command, &TSC);
-    if (mOn || (TSC < 0) || (TSC > 7))
+    if (TSC > 7) {
       sprintf(response, "RSP SETTSC 1 %d", TSC);
-    else if (chan && (TSC != mTSC))
-      sprintf(response, "RSP SETTSC 1 %d", TSC);
-    else {
+    } else {
+      LOG(NOTICE) << "Changing TSC from " << mTSC << " to " << TSC;
       mTSC = TSC;
       sprintf(response,"RSP SETTSC 0 %d", TSC);
     }
@@ -869,12 +829,20 @@ void Transceiver::driveControl(size_t chan)
 
 bool Transceiver::driveTxPriorityQueue(size_t chan)
 {
-  char buffer[gSlotLen+50];
+  int burstLen;
+  char buffer[EDGE_BURST_NBITS + 50];
 
   // check data socket
   size_t msgLen = mDataSockets[chan]->read(buffer, sizeof(buffer));
 
-  if (msgLen!=gSlotLen+1+4+1) {
+  if (msgLen == gSlotLen + 1 + 4 + 1) {
+    burstLen = gSlotLen;
+  } else if (msgLen == EDGE_BURST_NBITS + 1 + 4 + 1) {
+    if (mSPSTx != 4)
+      return false;
+
+    burstLen = EDGE_BURST_NBITS;
+  } else {
     LOG(ERR) << "badly formatted packet on GSM->TRX interface";
     return false;
   }
@@ -887,7 +855,7 @@ bool Transceiver::driveTxPriorityQueue(size_t chan)
   LOG(DEBUG) << "rcvd. burst at: " << GSM::Time(frameNum,timeSlot);
   
   int RSSI = (int) buffer[5];
-  static BitVector newBurst(gSlotLen);
+  BitVector newBurst(burstLen);
   BitVector::iterator itr = newBurst.begin();
   char *bufferItr = buffer+6;
   while (itr < newBurst.end()) 
@@ -942,6 +910,9 @@ void Transceiver::driveReceiveFIFO(size_t chan)
   if (!rxBurst)
     return;
 
+  // Convert -1..+1 soft bits to 0..1 soft bits
+  vectorSlicer(rxBurst);
+
   /*
    * EDGE demodulator returns 444 (148 * 3) bits
    */

Transceiver52M/Transceiver.h

@@ -84,6 +84,9 @@ struct TransceiverState {
 
   /* Shadowed downlink attenuation */
   int mPower;
+
+  /* Pseudorandom bit sequence */
+  PRBS9 mPrbs;
 };
 
 /** The Transceiver class, responsible for physical layer of basestation */
@@ -107,7 +110,7 @@ public:
   ~Transceiver();
 
   /** Start the control loop */
-  bool init(int filler, size_t rtsc, unsigned rach_delay);
+  bool init(int filler, size_t rtsc, unsigned rach_delay, bool edge);
 
   /** attach the radioInterface receive FIFO */
   bool receiveFIFO(VectorFIFO *wFIFO, size_t chan)
@@ -142,15 +145,6 @@ public:
     LOOPBACK            ///< similar go VII, used in loopback testing
   } ChannelCombination;
 
-  /** Codes for burst types of received bursts*/
-  typedef enum {
-    OFF,               ///< timeslot is off
-    TSC,	       ///< timeslot should contain a normal burst
-    RACH,	       ///< timeslot should contain an access burst
-    EDGE,	       ///< timeslot should contain an EDGE burst
-    IDLE	       ///< timeslot is an idle (or dummy) burst
-  } CorrType;
-
   enum FillerType {
     FILLER_DUMMY,
     FILLER_ZERO,
@@ -211,18 +205,11 @@ private:
   /** send messages over the clock socket */
   void writeClockInterface(void);
 
-  /** Detectbursts */
-  int detectBurst(signalVector &burst,
-                  complex &amp, float &toa, CorrType type);
-
-  /** Demodulate burst and output soft bits */
-  SoftVector *demodulate(signalVector &burst,
-                         complex amp, float toa, CorrType type);
-
   int mSPSTx;                          ///< number of samples per Tx symbol
   int mSPSRx;                          ///< number of samples per Rx symbol
   size_t mChans;
 
+  bool mEdge;
   bool mOn;	                           ///< flag to indicate that transceiver is powered on
   bool mHandover[8][8];                ///< expect handover to the timeslot/subslot
   double mTxFreq;                      ///< the transmit frequency

Transceiver52M/UHDDevice.cpp

@@ -1,8 +1,10 @@
 /*
  * Device support for Ettus Research UHD driver 
- * Written by Thomas Tsou <ttsou@vt.edu>
  *
  * Copyright 2010,2011 Free Software Foundation, Inc.
+ * Copyright (C) 2015 Ettus Research LLC
+ *
+ * Author: Tom Tsou <tom.tsou@ettus.com>
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU Affero General Public License as published by
@@ -26,18 +28,24 @@
 #include <uhd/property_tree.hpp>
 #include <uhd/usrp/multi_usrp.hpp>
 #include <uhd/utils/thread_priority.hpp>
-#include <uhd/utils/msg.hpp>
 
 #ifdef HAVE_CONFIG_H
 #include "config.h"
 #endif
 
+#ifndef USE_UHD_3_11
+#include <uhd/utils/msg.hpp>
+#endif
+
 #define B2XX_CLK_RT      26e6
+#define B2XX_MCBTS_CLK_RT   51.2e6
 #define E1XX_CLK_RT      52e6
+#define LIMESDR_CLK_RT   (GSMRATE*32)
 #define B100_BASE_RT     400000
 #define USRP2_BASE_RT    390625
 #define USRP_TX_AMPL     0.3
 #define UMTRX_TX_AMPL    0.7
+#define LIMESDR_TX_AMPL  0.3
 #define SAMPLE_BUF_SZ    (1 << 20)
 
 /*
@@ -59,10 +67,12 @@ enum uhd_dev_type {
 	B100,
 	B200,
 	B210,
+	B2XX_MCBTS,
 	E1XX,
 	E3XX,
 	X3XX,
 	UMTRX,
+	LIMESDR,
 	NUM_USRP_TYPES,
 };
 
@@ -77,14 +87,16 @@ struct uhd_dev_offset {
 /*
  * USRP version dependent device timings
  */
-#ifdef USE_UHD_3_9
+#if defined(USE_UHD_3_9) || defined(USE_UHD_3_11)
 #define B2XX_TIMING_1SPS	1.7153e-4
 #define B2XX_TIMING_4SPS	1.1696e-4
 #define B2XX_TIMING_4_4SPS	6.18462e-5
+#define B2XX_TIMING_MCBTS	7e-5
 #else
 #define B2XX_TIMING_1SPS	9.9692e-5
 #define B2XX_TIMING_4SPS	6.9248e-5
 #define B2XX_TIMING_4_4SPS	4.52308e-5
+#define B2XX_TIMING_MCBTS	6.42452e-5
 #endif
 
 /*
@@ -101,54 +113,52 @@ static struct uhd_dev_offset uhd_offsets[] = {
 	{ USRP1, 1, 1,       0.0, "USRP1 not supported" },
 	{ USRP1, 4, 1,       0.0, "USRP1 not supported"},
 	{ USRP2, 1, 1, 1.2184e-4, "N2XX 1 SPS" },
-	{ USRP2, 4, 1, 8.0230e-5, "N2XX 4 SPS" },
+	{ USRP2, 4, 1, 7.6547e-5, "N2XX 4/1 SPS" },
 	{ B100,  1, 1, 1.2104e-4, "B100 1 SPS" },
 	{ B100,  4, 1, 7.9307e-5, "B100 4 SPS" },
 	{ B200,  1, 1, B2XX_TIMING_1SPS, "B200 1 SPS" },
-	{ B200,  4, 1, B2XX_TIMING_4SPS, "B200 4 SPS" },
+	{ B200,  4, 1, B2XX_TIMING_4SPS, "B200 4/1 Tx/Rx SPS" },
 	{ B210,  1, 1, B2XX_TIMING_1SPS, "B210 1 SPS" },
-	{ B210,  4, 1, B2XX_TIMING_4SPS, "B210 4 SPS" },
+	{ B210,  4, 1, B2XX_TIMING_4SPS, "B210 4/1 Tx/Rx SPS" },
+	{ B2XX_MCBTS, 4, 4, B2XX_TIMING_MCBTS, "B200/B210 4 SPS Multi-ARFCN" },
 	{ E1XX,  1, 1, 9.5192e-5, "E1XX 1 SPS" },
-	{ E1XX,  4, 1, 6.5571e-5, "E1XX 4 SPS" },
+	{ E1XX,  4, 1, 6.5571e-5, "E1XX 4/1 Tx/Rx SPS" },
 	{ E3XX,  1, 1, 1.84616e-4, "E3XX 1 SPS" },
-	{ E3XX,  4, 1, 1.29231e-4, "E3XX 4 SPS" },
+	{ E3XX,  4, 1, 1.29231e-4, "E3XX 4/1 Tx/Rx SPS" },
 	{ X3XX,  1, 1, 1.5360e-4, "X3XX 1 SPS"},
-	{ X3XX,  4, 1, 1.1264e-4, "X3XX 4 SPS"},
+	{ X3XX,  4, 1, 1.1264e-4, "X3XX 4/1 Tx/Rx SPS"},
 	{ UMTRX, 1, 1, 9.9692e-5, "UmTRX 1 SPS" },
-	{ UMTRX, 4, 1, 7.3846e-5, "UmTRX 4 SPS" },
-	{ B200,  4, 4, B2XX_TIMING_4_4SPS, "B200/B210 EDGE mode (4 SPS TX/RX)" },
-	{ B210,  4, 4, B2XX_TIMING_4_4SPS, "B200/B210 EDGE mode (4 SPS TX/RX)" },
-	{ UMTRX, 4, 4, 5.1503e-5, "UmTRX EDGE mode (4 SPS TX/RX)" },
+	{ UMTRX, 4, 1, 7.3846e-5, "UmTRX 4/1 Tx/Rx SPS" },
+	{ USRP2, 4, 4, 4.6080e-5, "N2XX 4 SPS" },
+	{ B200,  4, 4, B2XX_TIMING_4_4SPS, "B200 4 SPS" },
+	{ B210,  4, 4, B2XX_TIMING_4_4SPS, "B210 4 SPS" },
+	{ X3XX,  4, 4, 5.6567e-5, "X3XX 4 SPS"},
+	{ UMTRX, 4, 4, 5.1503e-5, "UmTRX 4 SPS" },
+	{ LIMESDR, 4, 4, 16.5/GSMRATE, "STREAM/LimeSDR (4 SPS TX/RX)" },
 };
 #define NUM_UHD_OFFSETS (sizeof(uhd_offsets)/sizeof(uhd_offsets[0]))
 
-/*
- * Offset handling for special cases. Currently used for UmTRX dual channel
- * diversity receiver only.
- */
-static struct uhd_dev_offset special_offsets[] = {
-	{ UMTRX, 1, 1, 8.0875e-5, "UmTRX diversity, 1 SPS" },
-	{ UMTRX, 4, 1, 5.2103e-5, "UmTRX diversity, 4 SPS" },
-};
-
-
 /*
  * Select sample rate based on device type and requested samples-per-symbol.
  * The base rate is either GSM symbol rate, 270.833 kHz, or the minimum
  * usable channel spacing of 400 kHz.
  */
-static double select_rate(uhd_dev_type type, int sps, bool diversity = false)
+static double select_rate(uhd_dev_type type, int sps,
+			  RadioDevice::InterfaceType iface)
 {
-	if (diversity && (type == UMTRX)) {
-		return GSMRATE * 4;
-	} else if (diversity) {
-		LOG(ALERT) << "Diversity supported on UmTRX only";
-		return -9999.99;
-	}
-
 	if ((sps != 4) && (sps != 1))
 		return -9999.99;
 
+	if (iface == RadioDevice::MULTI_ARFCN) {
+		switch (type) {
+		case B2XX_MCBTS:
+			return  4 * MCBTS_SPACING;
+		default:
+			LOG(ALERT) << "Invalid device combination";
+			return -9999.99;
+		}
+	}
+
 	switch (type) {
 	case USRP2:
 	case X3XX:
@@ -160,6 +170,7 @@ static double select_rate(uhd_dev_type type, int sps, bool diversity = false)
 	case E1XX:
 	case E3XX:
 	case UMTRX:
+	case LIMESDR:
 		return GSMRATE * sps;
 	default:
 		break;
@@ -242,11 +253,11 @@ private:
 */
 class uhd_device : public RadioDevice {
 public:
-	uhd_device(size_t tx_sps, size_t rx_sps,
-		   size_t chans, bool diversity, double offset);
+	uhd_device(size_t tx_sps, size_t rx_sps, InterfaceType type,
+		   size_t chans, double offset);
 	~uhd_device();
 
-	int open(const std::string &args, bool extref, bool swap_channels);
+	int open(const std::string &args, int ref, bool swap_channels);
 	bool start();
 	bool stop();
 	bool restart();
@@ -264,8 +275,8 @@ public:
 	bool setTxFreq(double wFreq, size_t chan);
 	bool setRxFreq(double wFreq, size_t chan);
 
-	inline TIMESTAMP initialWriteTimestamp();
-	inline TIMESTAMP initialReadTimestamp();
+	TIMESTAMP initialWriteTimestamp();
+	TIMESTAMP initialReadTimestamp();
 
 	double fullScaleInputValue();
 	double fullScaleOutputValue();
@@ -328,7 +339,7 @@ private:
 	std::vector<smpl_buf *> rx_buffers;
 
 	void init_gains();
-	double get_dev_offset(bool edge, bool diversity);
+	double get_dev_offset();
 	int set_master_clk(double rate);
 	int set_rates(double tx_rate, double rx_rate);
 	bool parse_dev_type();
@@ -342,7 +353,7 @@ private:
 	bool set_freq(double freq, size_t chan, bool tx);
 
 	Thread *async_event_thrd;
-	bool diversity;
+	InterfaceType iface;
 	Mutex tune_lock;
 };
 
@@ -358,7 +369,8 @@ void *async_event_loop(uhd_device *dev)
 	return NULL;
 }
 
-/* 
+#ifndef USE_UHD_3_11
+/*
     Catch and drop underrun 'U' and overrun 'O' messages from stdout
     since we already report using the logging facility. Direct
     everything else appropriately.
@@ -379,6 +391,7 @@ void uhd_msg_handler(uhd::msg::type_t type, const std::string &msg)
 		break;
 	}
 }
+#endif
 
 static void thread_enable_cancel(bool cancel)
 {
@@ -387,7 +400,7 @@ static void thread_enable_cancel(bool cancel)
 }
 
 uhd_device::uhd_device(size_t tx_sps, size_t rx_sps,
-		       size_t chans, bool diversity, double offset)
+		       InterfaceType iface, size_t chans, double offset)
 	: tx_gain_min(0.0), tx_gain_max(0.0),
 	  rx_gain_min(0.0), rx_gain_max(0.0),
 	  tx_spp(0), rx_spp(0),
@@ -398,7 +411,7 @@ uhd_device::uhd_device(size_t tx_sps, size_t rx_sps,
 	this->rx_sps = rx_sps;
 	this->chans = chans;
 	this->offset = offset;
-	this->diversity = diversity;
+	this->iface = iface;
 }
 
 uhd_device::~uhd_device()
@@ -457,7 +470,7 @@ void uhd_device::init_gains()
 
 }
 
-double uhd_device::get_dev_offset(bool edge, bool diversity)
+double uhd_device::get_dev_offset()
 {
 	struct uhd_dev_offset *offset = NULL;
 
@@ -467,41 +480,13 @@ double uhd_device::get_dev_offset(bool edge, bool diversity)
 		return 0.0;
 	}
 
-	if (edge && diversity) {
-		LOG(ERR) << "Unsupported configuration";
-		return 0.0;
-	}
-
-	if (edge && (dev_type != B200) &&
-	    (dev_type != B210) && (dev_type != UMTRX)) {
-		LOG(ALERT) << "EDGE is supported on B200/B210 and UmTRX only";
-		return 0.0;
-	}
-
-	/* Special cases (e.g. diversity receiver) */
-	if (diversity) {
-		if (dev_type != UMTRX) {
-			LOG(ALERT) << "Diversity on UmTRX only";
-			return 0.0;
-		}
-
-		switch (tx_sps) {
-		case 1:
-			offset = &special_offsets[0];
+	/* Search for matching offset value */
+	for (size_t i = 0; i < NUM_UHD_OFFSETS; i++) {
+		if ((dev_type == uhd_offsets[i].type) &&
+			(tx_sps == uhd_offsets[i].tx_sps) &&
+			(rx_sps == uhd_offsets[i].rx_sps)) {
+			offset = &uhd_offsets[i];
 			break;
-		case 4:
-		default:
-			offset = &special_offsets[1];
-		}
-	} else {
-		/* Search for matching offset value */
-		for (size_t i = 0; i < NUM_UHD_OFFSETS; i++) {
-			if ((dev_type == uhd_offsets[i].type) &&
-				(tx_sps == uhd_offsets[i].tx_sps) &&
-				(rx_sps == uhd_offsets[i].rx_sps)) {
-				offset = &uhd_offsets[i];
-				break;
-			}
 		}
 	}
 
@@ -549,11 +534,18 @@ int uhd_device::set_rates(double tx_rate, double rx_rate)
 	if ((dev_type == B200) || (dev_type == B210) || (dev_type == E3XX)) {
 		if (set_master_clk(B2XX_CLK_RT) < 0)
 			return -1;
-	}
-	else if (dev_type == E1XX) {
+	} else if (dev_type == E1XX) {
 		if (set_master_clk(E1XX_CLK_RT) < 0)
 			return -1;
+	} else if (dev_type == B2XX_MCBTS) {
+		if (set_master_clk(B2XX_MCBTS_CLK_RT) < 0)
+			return -1;
 	}
+	else if (dev_type == LIMESDR) {
+		if (set_master_clk(LIMESDR_CLK_RT) < 0)
+			return -1;
+	}
+
 
 	// Set sample rates
 	try {
@@ -581,6 +573,9 @@ int uhd_device::set_rates(double tx_rate, double rx_rate)
 
 double uhd_device::setTxGain(double db, size_t chan)
 {
+	if (iface == MULTI_ARFCN)
+		chan = 0;
+
 	if (chan >= tx_gains.size()) {
 		LOG(ALERT) << "Requested non-existent channel" << chan;
 		return 0.0f;
@@ -627,6 +622,9 @@ double uhd_device::setRxGain(double db, size_t chan)
 
 double uhd_device::getRxGain(size_t chan)
 {
+	if (iface == MULTI_ARFCN)
+		chan = 0;
+
 	if (chan >= rx_gains.size()) {
 		LOG(ALERT) << "Requested non-existent channel " << chan;
 		return 0.0f;
@@ -646,7 +644,7 @@ bool uhd_device::parse_dev_type()
 	std::string mboard_str, dev_str;
 	uhd::property_tree::sptr prop_tree;
 	size_t usrp1_str, usrp2_str, e100_str, e110_str, e310_str, e3xx_str,
-	       b100_str, b200_str, b210_str, x300_str, x310_str, umtrx_str;
+	       b100_str, b200_str, b210_str, x300_str, x310_str, umtrx_str, limesdr_str;
 
 	prop_tree = usrp_dev->get_device()->get_tree();
 	dev_str = prop_tree->access<std::string>("/name").get();
@@ -664,6 +662,8 @@ bool uhd_device::parse_dev_type()
 	x300_str = mboard_str.find("X300");
 	x310_str = mboard_str.find("X310");
 	umtrx_str = dev_str.find("UmTRX");
+	// LimeSDR is based on STREAM board, so it's advertized as such
+	limesdr_str = dev_str.find("STREAM");
 
 	if (usrp1_str != std::string::npos) {
 		LOG(ALERT) << "USRP1 is not supported using the UHD driver";
@@ -703,6 +703,9 @@ bool uhd_device::parse_dev_type()
 	} else if (umtrx_str != std::string::npos) {
 		tx_window = TX_WINDOW_FIXED;
 		dev_type = UMTRX;
+	} else if (limesdr_str != std::string::npos) {
+		tx_window = TX_WINDOW_USRP1;
+		dev_type = LIMESDR;
 	} else {
 		LOG(ALERT) << "Unknown UHD device type "
 			   << dev_str << " " << mboard_str;
@@ -740,8 +743,10 @@ static bool uhd_e3xx_version_chk()
 	return true;
 }
 
-int uhd_device::open(const std::string &args, bool extref, bool swap_channels)
+int uhd_device::open(const std::string &args, int ref, bool swap_channels)
 {
+	const char *refstr;
+
 	// Find UHD devices
 	uhd::device_addr_t addr(args);
 	uhd::device_addrs_t dev_addrs = uhd::device::find(addr);
@@ -769,11 +774,24 @@ int uhd_device::open(const std::string &args, bool extref, bool swap_channels)
 	}
 
 	// Verify and set channels
-	if ((dev_type == B210) && (chans == 2)) {
-	} else if ((dev_type == UMTRX) && (chans == 2)) {
-		uhd::usrp::subdev_spec_t subdev_spec(swap_channels?"B:0 A:0":"A:0 B:0");
-		usrp_dev->set_tx_subdev_spec(subdev_spec);
-		usrp_dev->set_rx_subdev_spec(subdev_spec);
+	if (iface == MULTI_ARFCN) {
+		if ((dev_type != B200) && (dev_type != B210)) {
+			LOG(ALERT) << "Unsupported device configuration";
+			return -1;
+		}
+
+		dev_type = B2XX_MCBTS;
+		chans = 1;
+	} else if (chans == 2) {
+		if (dev_type == B210) {
+		} else if (dev_type == UMTRX) {
+			uhd::usrp::subdev_spec_t subdev_spec(swap_channels?"B:0 A:0":"A:0 B:0");
+			usrp_dev->set_tx_subdev_spec(subdev_spec);
+			usrp_dev->set_rx_subdev_spec(subdev_spec);
+		} else {
+			LOG(ALERT) << "Invalid device configuration";
+			return -1;
+		}
 	} else if (chans != 1) {
 		LOG(ALERT) << "Invalid channel combination for device";
 		return -1;
@@ -785,12 +803,26 @@ int uhd_device::open(const std::string &args, bool extref, bool swap_channels)
 	rx_gains.resize(chans);
 	rx_buffers.resize(chans);
 
-	if (extref)
-		usrp_dev->set_clock_source("external");
+	switch (ref) {
+	case REF_INTERNAL:
+		refstr = "internal";
+		break;
+	case REF_EXTERNAL:
+		refstr = "external";
+		break;
+	case REF_GPS:
+		refstr = "gpsdo";
+		break;
+	default:
+		LOG(ALERT) << "Invalid reference type";
+		return -1;
+	}
+
+	usrp_dev->set_clock_source(refstr);
 
 	// Set rates
-	double _tx_rate = select_rate(dev_type, tx_sps);
-	double _rx_rate = select_rate(dev_type, rx_sps, diversity);
+	double _rx_rate = select_rate(dev_type, rx_sps, iface);
+	double _tx_rate = select_rate(dev_type, tx_sps, iface);
 
 	if ((_tx_rate < 0.0) || (_rx_rate < 0.0))
 		return -1;
@@ -802,8 +834,12 @@ int uhd_device::open(const std::string &args, bool extref, bool swap_channels)
 		// Setting LMS6002D LPF to 500kHz gives us the best signal quality
 		for (size_t i = 0; i < chans; i++) {
 			usrp_dev->set_tx_bandwidth(500*1000*2, i);
-			if (!diversity)
-				usrp_dev->set_rx_bandwidth(500*1000*2, i);
+			usrp_dev->set_rx_bandwidth(500*1000*2, i);
+		}
+	} else if (dev_type == LIMESDR) {
+		for (size_t i = 0; i < chans; i++) {
+			usrp_dev->set_tx_bandwidth(5e6, i);
+			usrp_dev->set_rx_bandwidth(5e6, i);
 		}
 	}
 
@@ -827,11 +863,7 @@ int uhd_device::open(const std::string &args, bool extref, bool swap_channels)
 	// Set receive chain sample offset. Trigger the EDGE offset
 	// table by checking for 4 SPS on the receive path. No other
 	// configuration supports using 4 SPS.
-	bool edge = false;
-	if (rx_sps == 4)
-		edge = true;
-
-	double offset = get_dev_offset(edge, diversity);
+	double offset = get_dev_offset();
 	if (offset == 0.0) {
 		LOG(ERR) << "Unsupported configuration, no correction applied";
 		ts_offset = 0;
@@ -845,8 +877,8 @@ int uhd_device::open(const std::string &args, bool extref, bool swap_channels)
 	// Print configuration
 	LOG(INFO) << "\n" << usrp_dev->get_pp_string();
 
-	if (diversity)
-		return DIVERSITY;
+	if (iface == MULTI_ARFCN)
+		return MULTI_ARFCN;
 
 	switch (dev_type) {
 	case B100:
@@ -858,6 +890,7 @@ int uhd_device::open(const std::string &args, bool extref, bool swap_channels)
 	case B210:
 	case E1XX:
 	case E3XX:
+	case LIMESDR:
 	default:
 		break;
 	}
@@ -927,9 +960,10 @@ bool uhd_device::start()
 		return false;
 	}
 
+#ifndef USE_UHD_3_11
 	// Register msg handler
 	uhd::msg::register_handler(&uhd_msg_handler);
-
+#endif
 	// Start asynchronous event (underrun check) loop
 	async_event_thrd = new Thread();
 	async_event_thrd->start((void * (*)(void*))async_event_loop, (void*)this);
@@ -972,8 +1006,6 @@ void uhd_device::setPriority(float prio)
 
 int uhd_device::check_rx_md_err(uhd::rx_metadata_t &md, ssize_t num_smpls)
 {
-	uhd::time_spec_t ts;
-
 	if (!num_smpls) {
 		LOG(ERR) << str_code(md);
 
@@ -996,18 +1028,21 @@ int uhd_device::check_rx_md_err(uhd::rx_metadata_t &md, ssize_t num_smpls)
 		return ERROR_UNRECOVERABLE;
 	}
 
-	ts = md.time_spec;
-
 	// Monotonicity check
-	if (ts < prev_ts) {
+	if (md.time_spec < prev_ts) {
 		LOG(ALERT) << "UHD: Loss of monotonic time";
-		LOG(ALERT) << "Current time: " << ts.get_real_secs() << ", " 
+		LOG(ALERT) << "Current time: " << md.time_spec.get_real_secs() << ", "
 			   << "Previous time: " << prev_ts.get_real_secs();
 		return ERROR_TIMING;
-	} else {
-		prev_ts = ts;
 	}
 
+	// Workaround for UHD tick rounding bug
+	TIMESTAMP ticks = md.time_spec.to_ticks(rx_rate);
+	if (ticks - prev_ts.to_ticks(rx_rate) == rx_spp - 1)
+		md.time_spec = uhd::time_spec_t::from_ticks(++ticks, rx_rate);
+
+	prev_ts = md.time_spec;
+
 	return 0;
 }
 
@@ -1303,7 +1338,7 @@ double uhd_device::getRxFreq(size_t chan)
  */
 TIMESTAMP uhd_device::initialWriteTimestamp()
 {
-	if (rx_sps == tx_sps)
+	if ((iface == MULTI_ARFCN) || (rx_sps == tx_sps))
 		return ts_initial;
 	else
 		return ts_initial * tx_sps;
@@ -1316,6 +1351,8 @@ TIMESTAMP uhd_device::initialReadTimestamp()
 
 double uhd_device::fullScaleInputValue()
 {
+	if (dev_type == LIMESDR)
+		return (double) 2047 * LIMESDR_TX_AMPL;
 	if (dev_type == UMTRX)
 		return (double) SHRT_MAX * UMTRX_TX_AMPL;
 	else
@@ -1324,6 +1361,7 @@ double uhd_device::fullScaleInputValue()
 
 double uhd_device::fullScaleOutputValue()
 {
+	if (dev_type == LIMESDR) return (double) 2047;
 	return (double) SHRT_MAX;
 }
 
@@ -1580,7 +1618,7 @@ std::string smpl_buf::str_code(ssize_t code)
 }
 
 RadioDevice *RadioDevice::make(size_t tx_sps, size_t rx_sps,
-			       size_t chans, bool diversity, double offset)
+			       InterfaceType iface, size_t chans, double offset)
 {
-	return new uhd_device(tx_sps, rx_sps, chans, diversity, offset);
+	return new uhd_device(tx_sps, rx_sps, iface, chans, offset);
 }

Transceiver52M/USRPDevice.cpp

@@ -89,7 +89,7 @@ USRPDevice::USRPDevice(size_t sps)
 #endif
 }
 
-int USRPDevice::open(const std::string &, bool, bool)
+int USRPDevice::open(const std::string &, int, bool)
 {
   writeLock.unlock();
 
@@ -601,7 +601,7 @@ bool USRPDevice::setRxFreq(double wFreq) { return true;};
 #endif
 
 RadioDevice *RadioDevice::make(size_t tx_sps, size_t rx_sps,
-			       size_t chans, bool diversity, double)
+			       size_t chans, double)
 {
 	return new USRPDevice(tx_sps);
 }

Transceiver52M/USRPDevice.h

@@ -99,7 +99,7 @@ private:
   USRPDevice(size_t sps);
 
   /** Instantiate the USRP */
-  int open(const std::string &, bool, bool);
+  int open(const std::string &, int, bool);
 
   /** Start the USRP */
   bool start();

Transceiver52M/arm/convert.c

@@ -28,19 +28,6 @@
 void neon_convert_ps_si16_4n(short *, const float *, const float *, int);
 void neon_convert_si16_ps_4n(float *, const short *, int);
 
-#ifndef HAVE_NEON
-static void convert_si16_ps(float *out, const short *in, int len)
-{
-	for (int i = 0; i < len; i++)
-		out[i] = in[i];
-}
-
-static void convert_ps_si16(short *out, const float *in, float scale, int len)
-{
-	for (int i = 0; i < len; i++)
-		out[i] = in[i] * scale;
-}
-#else
 /* 4*N 16-bit signed integer conversion with remainder */
 static void neon_convert_si16_ps(float *out,
 				 const short *in,
@@ -79,7 +66,7 @@ void convert_float_short(short *out, const float *in, float scale, int len)
 	else
 		neon_convert_ps_si16_4n(out, in, q, len >> 2);
 #else
-	convert_ps_si16(out, in, scale, len);
+	base_convert_float_short(out, in, scale, len);
 #endif
 }
 
@@ -91,6 +78,6 @@ void convert_short_float(float *out, const short *in, int len)
 	else
 		neon_convert_si16_ps_4n(out, in, len >> 2);
 #else
-	convert_si16_ps(out, in, len);
+	base_convert_short_float(out, in, len);
 #endif
 }

Transceiver52M/arm/convolve.c

@@ -58,6 +58,13 @@ static void neon_conv_cmplx_4n(float *x, float *h, float *y, int h_len, int len)
 }
 #endif
 
+/* API: Initalize convolve module */
+void convolve_init(void)
+{
+	/* Stub */
+	return;
+}
+
 /* API: Aligned complex-real */
 int convolve_real(float *x, int x_len,
 		  float *h, int h_len,

Transceiver52M/common/convert.h

@@ -2,6 +2,14 @@
 #define _CONVERT_H_
 
 void convert_float_short(short *out, const float *in, float scale, int len);
+
 void convert_short_float(float *out, const short *in, int len);
 
+void base_convert_float_short(short *out, const float *in,
+			      float scale, int len);
+
+void base_convert_short_float(float *out, const short *in, int len);
+
+void convert_init(void);
+
 #endif /* _CONVERT_H_ */

Transceiver52M/common/convert_base.c

@@ -0,0 +1,34 @@
+/*
+ * Conversion
+ * Copyright (C) 2012, 2013 Thomas Tsou <tom@tsou.cc>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#include "convert.h"
+
+void base_convert_float_short(short *out, const float *in,
+			      float scale, int len)
+{
+	for (int i = 0; i < len; i++)
+		out[i] = in[i] * scale;
+}
+
+void base_convert_short_float(float *out, const short *in, int len)
+{
+	for (int i = 0; i < len; i++)
+		out[i] = in[i];
+}
+

Transceiver52M/common/convolve.h

@@ -27,4 +27,6 @@ int base_convolve_complex(const float *x, int x_len,
 			  int start, int len,
 			  int step, int offset);
 
+void convolve_init(void);
+
 #endif /* _CONVOLVE_H_ */

Transceiver52M/common/fft.c

@@ -0,0 +1,112 @@
+/*
+ * Fast Fourier transform 
+ *
+ * Copyright (C) 2012 Tom Tsou <tom@tsou.cc>
+ * 
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ * 
+ * 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 Affero General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program; if not, see <http://www.gnu.org/licenses/>.
+ * See the COPYING file in the main directory for details.
+ */
+
+#include <stdlib.h>
+#include <string.h>
+#include <assert.h>
+#include <fftw3.h>
+
+#include "fft.h"
+
+struct fft_hdl {
+	float *fft_in;
+	float *fft_out;
+	int len;
+	fftwf_plan fft_plan;
+};
+
+/*! \brief Initialize FFT backend 
+ *  \param[in] reverse FFT direction
+ *  \param[in] m FFT length 
+ *  \param[in] istride input stride count
+ *  \param[in] ostride output stride count
+ *  \param[in] in input buffer (FFTW aligned)
+ *  \param[in] out output buffer (FFTW aligned)
+ *  \param[in] ooffset initial offset into output buffer
+ *
+ * If the reverse is non-NULL, then an inverse FFT will be used. This is a
+ * wrapper for advanced non-contiguous FFTW usage. See FFTW documentation for
+ * further details.
+ *
+ *   http://www.fftw.org/doc/Advanced-Complex-DFTs.html
+ *
+ * It is currently unknown how the offset of the output buffer affects FFTW
+ * memory alignment.
+ */
+struct fft_hdl *init_fft(int reverse, int m, int istride, int ostride,
+			 float *in, float *out, int ooffset)
+{
+	int rank = 1;
+	int n[] = { m };
+	int howmany = istride;
+	int idist = 1;
+	int odist = 1;
+	int *inembed = n;
+	int *onembed = n;
+	fftwf_complex *obuffer, *ibuffer;
+
+	struct fft_hdl *hdl = (struct fft_hdl *) malloc(sizeof(struct fft_hdl));
+	if (!hdl)
+		return NULL;
+
+	int direction = FFTW_FORWARD;
+	if (reverse)
+		direction = FFTW_BACKWARD;
+
+	ibuffer = (fftwf_complex *) in;
+	obuffer = (fftwf_complex *) out + ooffset;
+
+	hdl->fft_in = in;
+	hdl->fft_out = out;
+	hdl->fft_plan = fftwf_plan_many_dft(rank, n, howmany,
+					    ibuffer, inembed, istride, idist,
+					    obuffer, onembed, ostride, odist,
+					    direction, FFTW_MEASURE);
+	return hdl;
+}
+
+void *fft_malloc(size_t size)
+{
+	return fftwf_malloc(size);
+}
+
+void fft_free(void *ptr)
+{
+	free(ptr);
+}
+
+/*! \brief Free FFT backend resources 
+ */
+void free_fft(struct fft_hdl *hdl)
+{
+	fftwf_destroy_plan(hdl->fft_plan);
+	free(hdl);
+}
+
+/*! \brief Run multiple DFT operations with the initialized plan
+ *  \param[in] hdl handle to an intitialized fft struct
+ *
+ * Input and output buffers are configured with init_fft().
+ */
+int cxvec_fft(struct fft_hdl *hdl)
+{
+	fftwf_execute(hdl->fft_plan);
+	return 0;
+}

Transceiver52M/common/fft.h

@@ -0,0 +1,13 @@
+#ifndef _FFT_H_
+#define _FFT_H_
+
+struct fft_hdl;
+
+struct fft_hdl *init_fft(int reverse, int m, int istride, int ostride,
+			 float *in, float *out, int ooffset);
+void *fft_malloc(size_t size);
+void fft_free(void *ptr);
+void free_fft(struct fft_hdl *hdl);
+int cxvec_fft(struct fft_hdl *hdl);
+
+#endif /* _FFT_H_ */

Transceiver52M/osmo-trx-dec.cpp

@@ -0,0 +1,520 @@
+/*
+ * Copyright (C) 2016-2017 Alexander Chemeris <Alexander.Chemeris@fairwaves.co>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include <limits.h>
+#include <fstream>
+#include <iomanip>
+
+#include "Logger.h"
+#include "sigProcLib.h"
+#include "signalVector.h"
+#include "Transceiver.h"
+#include "Configuration.h"
+
+extern "C" {
+#include "convolve.h"
+#include "convert.h"
+}
+
+#define DEFAULT_RX_SPS        1
+#define DEFAULT_SEARCH_WINDOW 30
+
+// Tail + data + stealing + midamble + guard (without the last 0.25)
+#define BURST_LEN_FULL        156
+// Tail + data + stealing + midamble
+#define BURST_LEN_ACTIVE      148
+// Tail + data + stealing + midamble - 2*0.5
+#define BURST_LEN_USEFUL      147
+
+// Size of a sample in bytes as stores in a file
+#define SAMPLE_SIZE_BYTES     (2 * sizeof(float))
+// Burst length in bytes as stored in a file
+#define BURST_LEN_BYTES       (BURST_LEN_FULL * SAMPLE_SIZE_BYTES)
+
+ConfigurationTable gConfig;
+
+struct trx_config {
+  std::string log_level;
+  unsigned sps;
+  unsigned tsc;
+  unsigned max_expected_delay_nb;
+  unsigned max_expected_delay_ab;
+  double full_scale;
+  bool edge;
+  CorrType type;
+  std::string filename;
+  unsigned ber_burst_avg;           ///< Average BER over this many bursts.
+                                    ///< Set to 0 to average for the whole duration.
+};
+
+class NormalBurstSoftbitMask {
+public:
+  NormalBurstSoftbitMask(SoftVector &softBits)
+  : mSoftBits(softBits)
+  {
+  }
+
+  SoftVector &bits() { return mSoftBits; }
+  SoftVector tailBitsL() { return mSoftBits.segment(0,3); }
+  SoftVector dataBitsL() { return mSoftBits.segment(3,57); }
+  SoftVector stealingBitsL() { return mSoftBits.segment(60, 1); }
+  SoftVector midambleBits() { return mSoftBits.segment(61, 26); }
+  SoftVector stealingBitsR() { return mSoftBits.segment(87, 1); }
+  SoftVector dataBitsR() { return mSoftBits.segment(88,57); }
+  SoftVector tailBitsR() { return mSoftBits.segment(145,3); }
+  SoftVector guardBits() { return mSoftBits.segment(148,8); }
+
+protected:
+  SoftVector &mSoftBits;
+};
+
+class SoftBurst {
+public:
+  SoftBurst(SoftVector *softBits, double toa=0)
+  : mSoftBits(softBits), mTOA(toa)
+  {
+    assert(mSoftBits != NULL);
+  }
+
+  ~SoftBurst()
+  {
+    delete mSoftBits;
+  }
+
+  void TOA(double TOA) { mTOA = TOA; }
+  double TOA() { return mTOA; }
+
+  NormalBurstSoftbitMask normalBurstMask() { return NormalBurstSoftbitMask(*mSoftBits); }
+
+protected:
+  SoftVector *mSoftBits;
+  double mTOA;
+};
+
+class BEREstimator {
+public:
+  BEREstimator(const PRBS& prbs)
+  : mPRBS(prbs), mTotalBits(0), mErrorBits(0), mSynchronized(false)
+  {}
+
+  unsigned synchronize(const BitVector &bits)
+  {
+    for (unsigned i=0; i<mPRBS.size(); i++) {
+      mPRBS.processBit(bits[i]);
+    }
+    mSynchronized = true;
+    return mPRBS.size();
+  }
+
+  void process(const BitVector &bits, size_t start_from = 0)
+  {
+    for (size_t i=start_from; i<bits.size(); i++) {
+      mTotalBits++;
+      if (mPRBS.generateBit() != bits.bit(i)) {
+        mErrorBits++;
+      }
+    }
+  }
+
+  void sync_and_process(const BitVector &bits)
+  {
+    unsigned skip = 0;
+    if (!mSynchronized) {
+      skip = synchronize(bits);
+    }
+
+    process(bits, skip);
+  }
+
+  void skip(size_t num)
+  {
+    for (size_t i=0; i<num; i++) {
+      mTotalBits++;
+      mErrorBits++;
+      mPRBS.generateBit();
+    }
+  }
+
+  void reset()
+  {
+    mTotalBits = 0;
+    mErrorBits = 0;
+  }
+
+  unsigned totalBits() const { return mTotalBits; }
+  unsigned errorBits() const { return mErrorBits; }
+  double BER() const { return mErrorBits/(double)mTotalBits; }
+
+  bool isSynchronized() const {return mSynchronized; }
+
+protected:
+  PRBS mPRBS;
+  unsigned mTotalBits;
+  unsigned mErrorBits;
+  bool mSynchronized;
+};
+
+double getBurstRSSI(const signalVector &burst, unsigned sps, double full_scale)
+{
+  /* Calculate average power of the burst */
+  float avg = energyDetect(burst, 20 * sps);
+  return 20.0 * log10(sqrt(avg) / full_scale);
+}
+
+void printDetectionResult(int rc)
+{
+  if (rc > 0) {
+    std::cout << "Detected correlation type: " << (CorrType)rc << std::endl;
+  } else {
+    if (rc == -SIGERR_CLIP) {
+      std::cout << "Clipping detected on received RACH or Normal Burst" << std::endl;
+    } else if (rc != SIGERR_NONE) {
+      std::cout << "Unhandled RACH or Normal Burst detection error" << std::endl;
+    } else {
+//      std::cout << "No burst detected" << std::endl;
+    }
+  }
+}
+
+SoftVector *demodulateBurst(const signalVector &burst,
+                            CorrType expected_type,
+                            unsigned sps, unsigned tsc,
+                            unsigned max_expected_delay,
+                            double &timingOffset)
+{
+  complex amp;
+  float toa;
+  int rc;
+  CorrType detected_type;
+
+  /* Detect normal or RACH bursts */
+  rc = detectAnyBurst(burst, tsc, BURST_THRESH, sps, expected_type, amp, toa,
+                      max_expected_delay);
+  printDetectionResult(rc);
+  if (rc <= 0) {
+    return NULL;
+  }
+
+  // Convert samples to symbols
+  timingOffset = toa / sps;
+  // rc > 0 means it's a detected CorrType
+  detected_type = (CorrType)rc;
+
+  return demodAnyBurst(burst, sps, amp, toa, detected_type);
+}
+
+static bool processBurst(const trx_config &config, signalVector &burst,
+                         unsigned max_expected_delay,
+                         double &RSSI,
+                         double &timingOffset,
+                         BEREstimator &berEstimator)
+{
+  RSSI = getBurstRSSI(burst, config.sps, config.full_scale);
+  SoftVector *softBits = demodulateBurst(burst, config.type, config.sps,config.tsc,
+                                         max_expected_delay, timingOffset);
+
+  /* Print burst information and content */
+  if (softBits == NULL) {
+    std::cout << "Skipped frame" << std::endl;
+    // TODO: This is different for EDGE
+    berEstimator.skip(57*2);
+    return false;
+  }
+
+  SoftBurst softBurst(softBits, timingOffset);
+  NormalBurstSoftbitMask nb = softBurst.normalBurstMask();
+
+  berEstimator.sync_and_process(nb.dataBitsL().sliced());
+  berEstimator.sync_and_process(nb.dataBitsR().sliced());
+
+  std::cout << "TOA:  " << softBurst.TOA() << " symbols" << std::endl;
+  // Exclude tail and guard bits from the energy calculation
+  std::cout << "Energy:  " << softBits->segment(3,142).getEnergy() << std::endl;
+  //std::cout << "Demodulated burst: " << *softBits << std::endl;
+  std::cout << "                  tail|--------------------------data---------------------------|f|--------midamble----------|f|--------------------------data---------------------------|tai|-guard--" << std::endl;
+  //           "                   000 010001011011110011101001100100000001010001011000100100010 0 11101111000100101110111100 0 011010111011101010011010111000101100001110101011011001011 000 1''..---"
+  std::cout << "Demodulated burst:"
+            << " " << nb.tailBitsL()
+            << " " << nb.dataBitsL()
+            << " " << nb.stealingBitsL()
+            << " " << nb.midambleBits()
+            << " " << nb.stealingBitsR()
+            << " " << nb.dataBitsR()
+            << " " << nb.tailBitsR()
+            << " " << nb.guardBits()
+            << std::endl;
+
+  return true;
+}
+
+// Setup configuration values
+static void print_config(struct trx_config *config)
+{
+  std::ostringstream ost("");
+  ost << "Config Settings" << std::endl;
+  ost << "   Source file name............. " << config->filename << std::endl;
+  ost << "   Log Level.................... " << config->log_level << std::endl;
+  ost << "   Rx Samples-per-Symbol........ " << config->sps << std::endl;
+  ost << "   EDGE support................. " << (config->edge ? "Enabled" : "Disabled") << std::endl;
+  ost << "   Burst type................... " << config->type << std::endl;
+  ost << "   Burst TSC.................... " << config->tsc << std::endl;
+  ost << "   Normal Burst search window... " << config->max_expected_delay_nb << std::endl;
+  ost << "   Access Burst search window... " << config->max_expected_delay_ab << std::endl;
+  ost << "   Signal full scale............ " << config->full_scale << std::endl;
+  ost << "   BER average window (bursts).. " << config->ber_burst_avg << std::endl;
+  std::cout << ost << std::endl;
+}
+
+static void print_help()
+{
+  fprintf(stdout, "Options:\n"
+          "  -h          This text\n"
+          "  -l LEVEL    Logging level (%s)\n"
+          "  -e          Enable EDGE receiver\n"
+          "  -s SPS      Samples-per-symbol (1 or 4, default: %d)\n"
+          "  -t TSC      Burst training sequence (0 to 7, default: 0)\n"
+          "  -f FILE     File to read\n"
+          "  -w SYMBOLS  Normal Burst search window (0 to 156, default: %d)\n"
+          "  -W SYMBOLS  Access Burst search window (0 to 156, default: %d)\n"
+          "  -b BURSTS   BER average window. Set to 0 to average over the whole file (default: 1)\n",
+          "EMERG, ALERT, CRT, ERR, WARNING, NOTICE, INFO, DEBUG",
+          DEFAULT_RX_SPS,
+          DEFAULT_SEARCH_WINDOW, DEFAULT_SEARCH_WINDOW);
+}
+
+static bool handle_options(int argc, char **argv, struct trx_config *config)
+{
+  int option;
+
+  config->log_level = "NOTICE";
+  config->sps = DEFAULT_RX_SPS;
+  config->tsc = 0;
+  config->max_expected_delay_nb = DEFAULT_SEARCH_WINDOW;
+  config->max_expected_delay_ab = DEFAULT_SEARCH_WINDOW;
+  config->full_scale = SHRT_MAX;
+  config->edge = false;
+  config->type = TSC;
+  config->ber_burst_avg = 1;
+
+  while ((option = getopt(argc, argv, "ls:et:f:w:W:b:h")) != -1) {
+    switch (option) {
+    case 'l':
+      config->log_level = optarg;
+      break;
+    case 's':
+      config->sps = atoi(optarg);
+      break;
+    case 'e':
+      config->edge = true;
+      break;
+    case 't':
+      config->tsc = atoi(optarg);
+      break;
+    case 'f':
+      config->filename = optarg;
+      break;
+    case 'w':
+      config->max_expected_delay_nb = atoi(optarg);
+      break;
+    case 'W':
+      config->max_expected_delay_ab = atoi(optarg);
+      break;
+    case 'b':
+      config->ber_burst_avg = atoi(optarg);
+      break;
+    case 'h':
+    default:
+      print_help();
+      exit(0);
+    }
+  }
+
+  if ((config->sps != 1) && (config->sps != 4)) {
+    printf("ERROR: Unsupported samples-per-symbol %i\n\n", config->sps);
+    return false;
+  }
+
+  if (config->edge && (config->sps != 4)) {
+    printf("ERROR: EDGE only supported at 4 samples per symbol\n\n");
+    return false;
+  }
+
+  if (config->tsc > 7) {
+    printf("ERROR: Invalid training sequence %i\n\n", config->tsc);
+    return false;
+  }
+
+  if (config->filename.length() == 0) {
+    printf("ERROR: No input file specified\n\n");
+    return false;
+  }
+
+  if (config->max_expected_delay_nb > 156 || config->max_expected_delay_nb < 0 ||
+      config->max_expected_delay_ab > 156 || config->max_expected_delay_ab < 0) {
+    printf("ERROR: Invalid search window size, must be withit [1..156] range\n\n");
+    return false;
+  }
+
+  return true;
+}
+
+int main(int argc, char *argv[])
+{
+  struct trx_config config;
+
+#ifdef HAVE_SSE3
+  printf("Info: SSE3 support compiled in");
+  if (__builtin_cpu_supports("sse3"))
+    printf(" and supported by CPU\n");
+  else
+    printf(", but not supported by CPU\n");
+#endif
+
+#ifdef HAVE_SSE4_1
+  printf("Info: SSE4.1 support compiled in");
+  if (__builtin_cpu_supports("sse4.1"))
+    printf(" and supported by CPU\n");
+  else
+    printf(", but not supported by CPU\n");
+#endif
+
+  convolve_init();
+  convert_init();
+
+  // Process command line options and print config to screen
+  if (!handle_options(argc, argv, &config)) {
+    print_help();
+    exit(0);
+  }
+  print_config(&config);
+
+  gLogInit("transceiver", config.log_level.c_str(), LOG_LOCAL7);
+
+  if (!sigProcLibSetup()) {
+    LOG(ALERT) << "Failed to initialize signal processing library";
+    return -1;
+  }
+
+  double RSSI;
+  double timingOffset, timingOffsetPrev = 0.0;
+  signalVector burst(2*BURST_LEN_FULL);
+  GSM::Time gsmTime;
+  bool syncedTo157bits = false; // We should syncronize to 156-157 frame structure only once
+  bool burst156_157 = false;    // Set to true to enable 156-156-156-157 frame
+  int bitsReadExtra = 0; // set to 1 every 4 bursts and when TOA>1.0
+  int bitsToSkip = 0;    // set to 1 when TOA<0.0
+  unsigned berBurstsAveraged = 0;
+  PRBS9 prbs;
+  BEREstimator berEstimator(prbs);
+
+  // Configure output stream
+  std::cout << std::fixed;
+  std::cout << std::setprecision(2);
+
+  std::ifstream file (config.filename.c_str(), std::ifstream::binary);
+
+  // Read the first burst, but do not process it, because we need at least two bursts
+  // worth of data for reliable initial detection.
+  file.read((char*)burst.begin(), config.sps * BURST_LEN_BYTES);
+  {signalVector t = burst.segment(0, BURST_LEN_FULL); scaleVector(t, complex(SHRT_MAX)); }
+
+#if 0
+    /* Distort signal */
+    {
+      signalVector burst_read = burst.segment(85,156);
+      std::ifstream file (config.filename.c_str(), std::ifstream::binary);
+      file.read((char*)burst_read.begin(), burst_read.size() * 2 * sizeof(float));
+      file.close();
+    }
+#endif
+#if 1
+  // Read more data and try burst detection until successful
+  while(file.read((char*)(burst.begin()+config.sps*BURST_LEN_FULL), config.sps*BURST_LEN_BYTES))
+  {
+    {signalVector t = burst.segment(BURST_LEN_FULL, BURST_LEN_FULL); scaleVector(t, complex(SHRT_MAX)); }
+    bool found = processBurst(config, burst, BURST_LEN_FULL, RSSI, timingOffset, berEstimator);
+    std::cout << "RSSI: " << RSSI << " dBFS" << std::endl;
+    if (found) {
+      gsmTime.incTN();
+      berBurstsAveraged++;
+      break;
+    }
+    burst.segmentMove(config.sps*BURST_LEN_FULL, 0, config.sps*BURST_LEN_FULL);
+  }
+
+  // Align stream to burst
+  int offsetInt = (int)timingOffset;
+  burst.segmentMove(config.sps*(BURST_LEN_FULL+offsetInt), 0, config.sps*(BURST_LEN_FULL-offsetInt));
+  {signalVector t = burst.segment(0, BURST_LEN_FULL-offsetInt); scaleVector(t, complex(1.0/SHRT_MAX)); }
+  file.read((char*)(burst.begin()+config.sps*(BURST_LEN_FULL-offsetInt)), config.sps*offsetInt*SAMPLE_SIZE_BYTES);
+#endif
+
+  // Resize burst vector to hold only one burst, because demodulation code
+  // always decode the full vector size.
+  burst.shrink(BURST_LEN_FULL+1);
+
+  // Process the rest of the stream
+  do {
+    {signalVector t = burst.segment(0, BURST_LEN_FULL); scaleVector(t, complex(SHRT_MAX)); }
+    processBurst(config, burst, (config.type==RACH)?config.max_expected_delay_ab:config.max_expected_delay_ab,
+                 RSSI, timingOffset, berEstimator);
+    if (burst156_157 && !syncedTo157bits && timingOffset - timingOffsetPrev > .75) {
+      std::cout << "TOA adjust: Found a 157-bit burst, reset TN to mark it" << std::endl;
+      gsmTime.TN(2);
+      timingOffset -= 1.0;
+      // Make sure we do this adjustment only once.
+      syncedTo157bits = true;
+    } else {
+      gsmTime.incTN();
+    }
+    bitsToSkip = 0;
+    bitsReadExtra = 0;
+    if (timingOffset < 0.0) {
+      std::cout << "TOA adjust: skip a bit" << std::endl;
+      burst[0] = 0;
+      bitsToSkip = 1;
+      bitsReadExtra--;
+    }
+    bitsReadExtra += (gsmTime.TN()%4 == 0);
+    if (timingOffset > 1.1) {
+      std::cout << "TOA adjust: add extra bit" << std::endl;
+      bitsReadExtra++;
+    }
+    std::cout << "Clock: " << gsmTime;
+    std::cout << " RSSI: " << RSSI << " dBFS";
+    std::cout << " Error bits: " << berEstimator.errorBits() << " Total bits: " << berEstimator.totalBits()
+              << " BER: " << 100.0*berEstimator.errorBits() / berEstimator.totalBits() << "%" << std::endl;
+    berBurstsAveraged++;
+    // Never reset if config.ber_burst_avg is 0
+    if (config.ber_burst_avg > 0 && berBurstsAveraged >= config.ber_burst_avg) {
+        berBurstsAveraged = 0;
+        berEstimator.reset();
+    }
+    std::cout << "bitsReadExtra: " << bitsReadExtra << " bitsToSkip: " << bitsToSkip << std::endl;
+    timingOffsetPrev = timingOffset;
+  } while(file.read((char*)(burst.begin()+bitsToSkip), config.sps*(BURST_LEN_BYTES+SAMPLE_SIZE_BYTES*bitsReadExtra)));
+
+  std::cout << "End of file reached" << std::endl;
+  file.close();
+
+  return 0;
+}

Transceiver52M/osmo-trx-gen.cpp

@@ -0,0 +1,334 @@
+/*
+ * Copyright (C) 2017 Alexander Chemeris <Alexander.Chemeris@fairwaves.co>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include <limits.h>
+#include <fstream>
+#include <iomanip>
+#include <endian.h> // for byte order manipulation
+
+#include "Logger.h"
+#include "sigProcLib.h"
+#include "GSMCommon.h"
+#include "BitVector.h"
+#include "Configuration.h"
+
+extern "C" {
+#include "convolve.h"
+#include "convert.h"
+}
+
+#define DEFAULT_SPS           4
+#define DEFAULT_SEARCH_WINDOW 30
+
+// Tail + data + stealing + midamble + guard (without the last 0.25)
+#define BURST_LEN_FULL        156
+// Tail + data + stealing + midamble
+#define BURST_LEN_ACTIVE      148
+// Tail + data + stealing + midamble - 2*0.5
+#define BURST_LEN_USEFUL      147
+
+// Size of a sample in bytes as stores in a file
+#define SAMPLE_SIZE_BYTES     (2 * sizeof(float))
+// Burst length in bytes as stored in a file
+#define BURST_LEN_BYTES       (BURST_LEN_FULL * SAMPLE_SIZE_BYTES)
+
+ConfigurationTable gConfig;
+
+enum FileType {
+  FLOAT_NORM_LE,  ///< Float -1..+1 Little Endian
+  FLOAT16_LE,     ///< Float -32767..+32767 Little Endian
+  SIGNED16_LE,    ///< Integer -32767..+32767 Little Endian
+  SIGNED16_BE,    ///< Integer -32767..+32767 Big Endian (Keysight waveform format)
+};
+
+struct trx_config {
+  std::string log_level;
+  unsigned sps;
+  unsigned tsc;
+  double full_scale;
+  bool edge;
+  CorrType type;
+  std::string filename;
+  FileType file_type;
+};
+
+std::ostream& operator<<(std::ostream& os, FileType ftype)
+{
+  switch(ftype)
+  {
+  case FLOAT_NORM_LE:
+    os << "float";
+    break;
+  case FLOAT16_LE:
+    os << "float16";
+    break;
+  case SIGNED16_LE:
+    os << "signed16";
+    break;
+  case SIGNED16_BE:
+    os << "signed16be";
+    break;
+  default:
+    assert(!"unknown file type");
+  }
+	return os;
+}
+
+
+void writeBurstFloatNorm(std::ofstream& os, const signalVector& v)
+{
+  os.write((char*)v.begin(), v.size() * 2 * sizeof(float));
+}
+
+void writeBurstFloat16LE(std::ofstream& os, const signalVector& v)
+{
+  const complex *c = v.begin();
+  for (size_t i=0; i<v.size(); i++, c++) {
+    float iq[2];
+    iq[0] = c->real()*SHRT_MAX;
+    iq[1] = c->imag()*SHRT_MAX;
+    os.write((char*)&iq, 2*sizeof(float));
+  }
+}
+
+void writeBurstSigned16LE(std::ofstream& os, const signalVector& v)
+{
+  const complex *c = v.begin();
+  for (size_t i=0; i<v.size(); i++, c++) {
+    int16_t iq[2];
+    iq[0] = c->real()*SHRT_MAX;
+    iq[1] = c->imag()*SHRT_MAX;
+    iq[0] = htole16(iq[0]);
+    iq[1] = htole16(iq[1]);
+    os.write((char*)&iq, 2*sizeof(int16_t));
+  }
+}
+
+void writeBurstSigned16BE(std::ofstream& os, const signalVector& v)
+{
+  const complex *c = v.begin();
+  for (size_t i=0; i<v.size(); i++, c++) {
+    int16_t iq[2];
+    iq[0] = c->real()*SHRT_MAX;
+    iq[1] = c->imag()*SHRT_MAX;
+    iq[0] = htobe16(iq[0]);
+    iq[1] = htobe16(iq[1]);
+    os.write((char*)&iq, 2*sizeof(int16_t));
+  }
+}
+
+void writeBurst(std::ofstream& os, const signalVector& v, FileType ftype)
+{
+  switch(ftype)
+  {
+  case FLOAT_NORM_LE:
+    writeBurstFloatNorm(os, v);
+    break;
+  case FLOAT16_LE:
+    writeBurstFloat16LE(os, v);
+    break;
+  case SIGNED16_LE:
+    writeBurstSigned16LE(os, v);
+    break;
+  case SIGNED16_BE:
+    writeBurstSigned16BE(os, v);
+    break;
+  default:
+    assert(!"unknown file type");
+  }
+}
+
+// Setup configuration values
+static void print_config(struct trx_config *config)
+{
+  std::ostringstream ost("");
+  ost << "Config Settings" << std::endl;
+  ost << "   Destination file name........ " << config->filename << std::endl;
+  ost << "   Destination file type........ " << config->file_type << std::endl;
+  ost << "   Log Level.................... " << config->log_level << std::endl;
+  ost << "   Tx Samples-per-Symbol........ " << config->sps << std::endl;
+  ost << "   EDGE support................. " << (config->edge ? "Enabled" : "Disabled") << std::endl;
+  ost << "   Burst type................... " << config->type << std::endl;
+  ost << "   Burst TSC.................... " << config->tsc << std::endl;
+  ost << "   Signal full scale............ " << config->full_scale << std::endl;
+  std::cout << ost << std::endl;
+}
+
+static void print_help()
+{
+  fprintf(stdout,
+          "This utility generates waveform files aka IQ binary files in a number of formats"
+          "to use them as input to osmo-trx-dec or load them into signal generators.\n"
+          "\n"
+          "Options:\n"
+          "  -h          This text\n"
+          "  -l LEVEL    Logging level (%s)\n"
+          "  -e          Enable EDGE receiver\n"
+          "  -s SPS      Samples-per-symbol (1 or 4, default: %d)\n"
+          "  -t TSC      Burst training sequence (0 to 7, default: 0)\n"
+          "  -f FILE     File to write generated bursts to\n"
+          "  -F FILETYPE Format of the file - float, float16, signed16, signed16be (default: f16)\n"
+          "              Note: Keysight waveform format is signed16be. osmo-trx-dec accepts float16.\n",
+          "EMERG, ALERT, CRT, ERR, WARNING, NOTICE, INFO, DEBUG",
+          DEFAULT_SPS);
+}
+
+FileType option_to_file_type(const std::string &optarg)
+{
+  if (optarg == "float") {
+    return FLOAT_NORM_LE;
+  } else if (optarg == "float16") {
+    return FLOAT16_LE;
+  } else if (optarg == "signed16") {
+    return SIGNED16_LE;
+  } else if (optarg == "signed16be") {
+    return SIGNED16_BE;
+  } else {
+    return (FileType)-1;
+  }
+}
+
+static bool handle_options(int argc, char **argv, struct trx_config *config)
+{
+  int option;
+
+  config->log_level = "NOTICE";
+  config->sps = DEFAULT_SPS;
+  config->tsc = 0;
+  config->full_scale = SHRT_MAX;
+  config->edge = false;
+  config->type = TSC;
+  config->file_type = FLOAT16_LE;
+
+  while ((option = getopt(argc, argv, "ls:et:f:F:h")) != -1) {
+    switch (option) {
+    case 'l':
+      config->log_level = optarg;
+      break;
+    case 's':
+      config->sps = atoi(optarg);
+      break;
+    case 'e':
+      config->edge = true;
+      break;
+    case 't':
+      config->tsc = atoi(optarg);
+      break;
+    case 'f':
+      config->filename = optarg;
+      break;
+    case 'F':
+      config->file_type = option_to_file_type(optarg);
+      break;
+    case 'h':
+    default:
+      print_help();
+      exit(0);
+    }
+  }
+
+  if ((config->sps != 1) && (config->sps != 4)) {
+    printf("ERROR: Unsupported samples-per-symbol %i\n\n", config->sps);
+    return false;
+  }
+
+  if (config->edge && (config->sps != 4)) {
+    printf("ERROR: EDGE only supported at 4 samples per symbol\n\n");
+    return false;
+  }
+
+  if (config->tsc > 7) {
+    printf("ERROR: Invalid training sequence %i\n\n", config->tsc);
+    return false;
+  }
+
+  if (config->filename.length() == 0) {
+    printf("ERROR: No output file name specified\n\n");
+    return false;
+  }
+
+  if (config->file_type < 0) {
+    printf("ERROR: Wrong output file format\n\n");
+  }
+
+  return true;
+}
+
+int main(int argc, char *argv[])
+{
+  struct trx_config config;
+
+#ifdef HAVE_SSE3
+  printf("Info: SSE3 support compiled in");
+  if (__builtin_cpu_supports("sse3"))
+    printf(" and supported by CPU\n");
+  else
+    printf(", but not supported by CPU\n");
+#endif
+
+#ifdef HAVE_SSE4_1
+  printf("Info: SSE4.1 support compiled in");
+  if (__builtin_cpu_supports("sse4.1"))
+    printf(" and supported by CPU\n");
+  else
+    printf(", but not supported by CPU\n");
+#endif
+
+  convolve_init();
+  convert_init();
+
+  // Process command line options and print config to screen
+  if (!handle_options(argc, argv, &config)) {
+    print_help();
+    exit(0);
+  }
+  print_config(&config);
+
+  gLogInit("transceiver", config.log_level.c_str(), LOG_LOCAL7);
+
+  if (!sigProcLibSetup()) {
+    LOG(ALERT) << "Failed to initialize signal processing library";
+    return -1;
+  }
+
+  signalVector burst(2*BURST_LEN_FULL);
+  GSM::Time gsmTime;
+  PRBS9 prbs;
+
+  // Configure output stream
+  std::cout << std::fixed;
+  std::cout << std::setprecision(2);
+
+  std::ofstream file (config.filename.c_str(), std::ifstream::binary);
+
+  for (int i=0; i<511; i++) {
+    signalVector *signal = genRandNormalBurst(config.tsc, config.sps, gsmTime.TN(), prbs);
+    writeBurst(file, *signal, config.file_type);
+    gsmTime.incTN();
+  }
+
+  file.close();
+
+  std::cout << "Done!" << std::endl;
+
+  return 0;
+}

Transceiver52M/osmo-trx.cpp

@@ -32,6 +32,11 @@
 #include <Logger.h>
 #include <Configuration.h>
 
+extern "C" {
+#include "convolve.h"
+#include "convert.h"
+}
+
 /* Samples-per-symbol for downlink path
  *     4 - Uses precision modulator (more computation, less distortion)
  *     1 - Uses minimized modulator (less computation, more distortion)
@@ -49,16 +54,9 @@
  */
 #define DEFAULT_RX_SPS		1
 
-/* Default configuration parameters
- *     Note that these values are only used if the particular key does not
- *     exist in the configuration database. IP port and address values will
- *     typically be overwritten by the OpenBTS.db values. Other values will
- *     not be in the database by default.
- */
+/* Default configuration parameters */
 #define DEFAULT_TRX_PORT	5700
 #define DEFAULT_TRX_IP		"127.0.0.1"
-#define DEFAULT_EXTREF		false
-#define DEFAULT_DIVERSITY	false
 #define DEFAULT_CHANS		1
 
 struct trx_config {
@@ -72,8 +70,9 @@ struct trx_config {
 	unsigned rtsc;
 	unsigned rach_delay;
 	bool extref;
+	bool gpsref;
 	Transceiver::FillerType filler;
-	bool diversity;
+	bool mcbts;
 	double offset;
 	double rssi_offset;
 	bool swap_channels;
@@ -84,40 +83,6 @@ ConfigurationTable gConfig;
 
 volatile bool gshutdown = false;
 
-/* Run sanity check on configuration table
- *     The global table constructor cannot provide notification in the
- *     event of failure. Make sure that we can access the database,
- *     write to it, and that it contains the bare minimum required keys.
- */
-bool testConfig()
-{
-	int val = 9999;
-	std::string test = "asldfkjsaldkf";
-	const char *key = "Log.Level";
-
-	/* Attempt to query */
-	try {
-		gConfig.getStr(key);
-	} catch (...) {
-		std::cerr << std::endl;
-		std::cerr << "Config: Failed query required key " << key
-			  << std::endl;
-		return false;
-	}
-
-	/* Attempt to set a test value in the global config */
-	if (!gConfig.set(test, val)) {
-		std::cerr << std::endl;
-		std::cerr << "Config: Failed to set test key" << std::endl;
-		return false;
-	} else {
-		gConfig.remove(test);
-	}
-
-	return true;
-}
-
-
 /* Setup configuration values
  *     Don't query the existence of the Log.Level because it's a
  *     mandatory value. That is, if it doesn't exist, the configuration
@@ -127,49 +92,23 @@ bool testConfig()
  */
 bool trx_setup_config(struct trx_config *config)
 {
-	std::string refstr, fillstr, divstr, edgestr;
+	std::string refstr, fillstr, divstr, mcstr, edgestr;
 
-	if (!testConfig())
+	if (config->mcbts && config->chans > 5) {
+		std::cout << "Unsupported number of channels" << std::endl;
 		return false;
-
-	if (config->log_level == "")
-		config->log_level = gConfig.getStr("Log.Level");
-
-	if (!config->port) {
-		if (gConfig.defines("TRX.Port"))
-			config->port = gConfig.getNum("TRX.Port");
-		else
-			config->port = DEFAULT_TRX_PORT;
 	}
 
-	if (config->addr == "") {
-		if (gConfig.defines("TRX.IP"))
-			config->addr = gConfig.getStr("TRX.IP");
-		else
-			config->addr = DEFAULT_TRX_IP;
-	}
-
-	if (!config->extref) {
-		if (gConfig.defines("TRX.Reference"))
-			config->extref = gConfig.getNum("TRX.Reference");
-		else
-			config->extref = DEFAULT_EXTREF;
-	}
-
-	if (!config->diversity) {
-		if (gConfig.defines("TRX.Diversity"))
-			config->diversity = gConfig.getNum("TRX.Diversity");
-		else
-			config->diversity = DEFAULT_DIVERSITY;
-	}
-
-	/* Diversity only supported on 2 channels */
-	if (config->diversity)
-		config->chans = 2;
-
 	edgestr = config->edge ? "Enabled" : "Disabled";
-	refstr = config->extref ? "Enabled" : "Disabled";
-	divstr = config->diversity ? "Enabled" : "Disabled";
+	mcstr = config->mcbts ? "Enabled" : "Disabled";
+
+	if (config->extref)
+		refstr = "External";
+	else if (config->gpsref)
+		refstr = "GPS";
+	else
+		refstr = "Internal";
+
 	switch (config->filler) {
 	case Transceiver::FILLER_DUMMY:
 		fillstr = "Dummy bursts";
@@ -198,9 +137,9 @@ bool trx_setup_config(struct trx_config *config)
 	ost << "   Tx Samples-per-Symbol... " << config->tx_sps << std::endl;
 	ost << "   Rx Samples-per-Symbol... " << config->rx_sps << std::endl;
 	ost << "   EDGE support............ " << edgestr << std::endl;
-	ost << "   External Reference...... " << refstr << std::endl;
+	ost << "   Reference............... " << refstr << std::endl;
 	ost << "   C0 Filler Table......... " << fillstr << std::endl;
-	ost << "   Diversity............... " << divstr << std::endl;
+	ost << "   Multi-Carrier........... " << mcstr << std::endl;
 	ost << "   Tuning offset........... " << config->offset << std::endl;
 	ost << "   RSSI to dBm offset...... " << config->rssi_offset << std::endl;
 	ost << "   Swap channels........... " << config->swap_channels << std::endl;
@@ -221,10 +160,6 @@ RadioInterface *makeRadioInterface(struct trx_config *config,
 {
 	RadioInterface *radio = NULL;
 
-	if ((config->rx_sps != 1) && (type != RadioDevice::NORMAL)) {
-		LOG(ALERT) << "Unsupported radio interface configuration";
-	}
-
 	switch (type) {
 	case RadioDevice::NORMAL:
 		radio = new RadioInterface(usrp, config->tx_sps,
@@ -233,11 +168,11 @@ RadioInterface *makeRadioInterface(struct trx_config *config,
 	case RadioDevice::RESAMP_64M:
 	case RadioDevice::RESAMP_100M:
 		radio = new RadioInterfaceResamp(usrp, config->tx_sps,
-						 config->chans);
+						 config->rx_sps);
 		break;
-	case RadioDevice::DIVERSITY:
-		radio = new RadioInterfaceDiversity(usrp, config->tx_sps,
-						    config->chans);
+	case RadioDevice::MULTI_ARFCN:
+		radio = new RadioInterfaceMulti(usrp, config->tx_sps,
+						config->rx_sps, config->chans);
 		break;
 	default:
 		LOG(ALERT) << "Unsupported radio interface configuration";
@@ -266,7 +201,8 @@ Transceiver *makeTransceiver(struct trx_config *config, RadioInterface *radio)
 	trx = new Transceiver(config->port, config->addr.c_str(),
 			      config->tx_sps, config->rx_sps, config->chans,
 			      GSM::Time(3,0), radio, config->rssi_offset);
-	if (!trx->init(config->filler, config->rtsc, config->rach_delay)) {
+	if (!trx->init(config->filler, config->rtsc,
+		       config->rach_delay, config->edge)) {
 		LOG(ALERT) << "Failed to initialize transceiver";
 		delete trx;
 		return NULL;
@@ -312,13 +248,16 @@ static void print_help()
 		"  -i    IP address of GSM core\n"
 		"  -p    Base port number\n"
 		"  -e    Enable EDGE receiver\n"
-		"  -d    Enable dual channel diversity receiver\n"
+		"  -m    Enable multi-ARFCN transceiver (default=disabled)\n"
 		"  -x    Enable external 10 MHz reference\n"
-		"  -s    Samples-per-symbol (1 or 4)\n"
+		"  -g    Enable GPSDO reference\n"
+		"  -s    Tx samples-per-symbol (1 or 4)\n"
+		"  -b    Rx samples-per-symbol (1 or 4)\n"
 		"  -c    Number of ARFCN channels (default=1)\n"
 		"  -f    Enable C0 filler table\n"
 		"  -o    Set baseband frequency offset (default=auto)\n"
-		"  -r    Random Normal Burst test mode with TSC\n"
+		"  -r    Random GMSK Normal Burst test mode with given TSC\n"
+		"  -E    Random 8-PSK Normal Burst test mode with given TSC\n"
 		"  -A    Random Access Burst test mode with delay\n"
 		"  -R    RSSI to dBm offset in dB (default=0)\n"
 		"  -S    Swap channels (UmTRX only)\n",
@@ -329,21 +268,24 @@ static void handle_options(int argc, char **argv, struct trx_config *config)
 {
 	int option;
 
-	config->port = 0;
+	config->log_level = "NOTICE";
+	config->addr = DEFAULT_TRX_IP;
+	config->port = DEFAULT_TRX_PORT;
 	config->tx_sps = DEFAULT_TX_SPS;
 	config->rx_sps = DEFAULT_RX_SPS;
 	config->chans = DEFAULT_CHANS;
 	config->rtsc = 0;
 	config->rach_delay = 0;
 	config->extref = false;
+	config->gpsref = false;
 	config->filler = Transceiver::FILLER_ZERO;
-	config->diversity = false;
+	config->mcbts = false;
 	config->offset = 0.0;
 	config->rssi_offset = 0.0;
 	config->swap_channels = false;
 	config->edge = false;
 
-	while ((option = getopt(argc, argv, "ha:l:i:p:c:dxfo:s:r:A:R:Se")) != -1) {
+	while ((option = getopt(argc, argv, "ha:l:i:p:c:dmxgfo:s:b:r:E:A:R:Se")) != -1) {
 		switch (option) {
 		case 'h':
 			print_help();
@@ -364,12 +306,15 @@ static void handle_options(int argc, char **argv, struct trx_config *config)
 		case 'c':
 			config->chans = atoi(optarg);
 			break;
-		case 'd':
-			config->diversity = true;
+		case 'm':
+			config->mcbts = true;
 			break;
 		case 'x':
 			config->extref = true;
 			break;
+		case 'g':
+			config->gpsref = true;
+			break;
 		case 'f':
 			config->filler = Transceiver::FILLER_DUMMY;
 			break;
@@ -379,10 +324,17 @@ static void handle_options(int argc, char **argv, struct trx_config *config)
 		case 's':
 			config->tx_sps = atoi(optarg);
 			break;
+		case 'b':
+			config->rx_sps = atoi(optarg);
+			break;
 		case 'r':
 			config->rtsc = atoi(optarg);
 			config->filler = Transceiver::FILLER_NORM_RAND;
 			break;
+		case 'E':
+			config->rtsc = atoi(optarg);
+			config->filler = Transceiver::FILLER_EDGE_RAND;
+			break;
 		case 'A':
 			config->rach_delay = atoi(optarg);
 			config->filler = Transceiver::FILLER_ACCESS_RAND;
@@ -395,7 +347,6 @@ static void handle_options(int argc, char **argv, struct trx_config *config)
 			break;
 		case 'e':
 			config->edge = true;
-			config->rx_sps = 4;
 			break;
 		default:
 			print_help();
@@ -403,42 +354,73 @@ static void handle_options(int argc, char **argv, struct trx_config *config)
 		}
 	}
 
-	if (config->edge && (config->filler == Transceiver::FILLER_NORM_RAND))
-		config->filler = Transceiver::FILLER_EDGE_RAND;
-
-	if ((config->tx_sps != 1) && (config->tx_sps != 4)) {
-		printf("Unsupported samples-per-symbol %i\n\n", config->tx_sps);
-		print_help();
-		exit(0);
+	/* Force 4 SPS for EDGE or multi-ARFCN configurations */
+	if ((config->edge) || (config->mcbts)) {
+		config->tx_sps = 4;
+		config->rx_sps = 4;
 	}
 
-	if (config->edge && (config->tx_sps != 4)) {
-		printf("EDGE only supported at 4 samples per symbol\n\n");
-		print_help();
-		exit(0);
+	if (config->gpsref && config->extref) {
+		printf("External and GPSDO references unavailable at the same time\n\n");
+		goto bad_config;
+	}
+
+	if (!config->edge && (config->filler == Transceiver::FILLER_EDGE_RAND)) {
+		printf("Can't enable EDGE filler when EDGE mode is disabled\n\n");
+		goto bad_config;
+	}
+
+	if ((config->tx_sps != 1) && (config->tx_sps != 4) &&
+	    (config->rx_sps != 1) && (config->rx_sps != 4)) {
+		printf("Unsupported samples-per-symbol %i\n\n", config->tx_sps);
+		goto bad_config;
 	}
 
 	if (config->rtsc > 7) {
 		printf("Invalid training sequence %i\n\n", config->rtsc);
-		print_help();
-		exit(0);
+		goto bad_config;
 	}
 
 	if (config->rach_delay > 68) {
 		printf("RACH delay is too big %i\n\n", config->rach_delay);
-		print_help();
-		exit(0);
+		goto bad_config;
 	}
+
+	return;
+
+bad_config:
+	print_help();
+	exit(0);
 }
 
 int main(int argc, char *argv[])
 {
-	int type, chans;
+	int type, chans, ref;
 	RadioDevice *usrp;
 	RadioInterface *radio = NULL;
 	Transceiver *trx = NULL;
+	RadioDevice::InterfaceType iface = RadioDevice::NORMAL;
 	struct trx_config config;
 
+#ifdef HAVE_SSE3
+	printf("Info: SSE3 support compiled in");
+	if (__builtin_cpu_supports("sse3"))
+		printf(" and supported by CPU\n");
+	else
+		printf(", but not supported by CPU\n");
+#endif
+
+#ifdef HAVE_SSE4_1
+	printf("Info: SSE4.1 support compiled in");
+	if (__builtin_cpu_supports("sse4.1"))
+		printf(" and supported by CPU\n");
+	else
+		printf(", but not supported by CPU\n");
+#endif
+
+	convolve_init();
+	convert_init();
+
 	handle_options(argc, argv, &config);
 
 	setup_signal_handlers();
@@ -454,9 +436,19 @@ int main(int argc, char *argv[])
 	srandom(time(NULL));
 
 	/* Create the low level device object */
-	usrp = RadioDevice::make(config.tx_sps, config.rx_sps, config.chans,
-				 config.diversity, config.offset);
-	type = usrp->open(config.dev_args, config.extref, config.swap_channels);
+	if (config.mcbts)
+		iface = RadioDevice::MULTI_ARFCN;
+
+	if (config.extref)
+		ref = RadioDevice::REF_EXTERNAL;
+	else if (config.gpsref)
+		ref = RadioDevice::REF_GPS;
+	else
+		ref = RadioDevice::REF_INTERNAL;
+
+	usrp = RadioDevice::make(config.tx_sps, config.rx_sps, iface,
+				 config.chans, config.offset);
+	type = usrp->open(config.dev_args, ref, config.swap_channels);
 	if (type < 0) {
 		LOG(ALERT) << "Failed to create radio device" << std::endl;
 		goto shutdown;

Transceiver52M/radioBuffer.cpp

@@ -0,0 +1,228 @@
+/*
+ * Segmented Ring Buffer
+ *
+ * Copyright (C) 2015 Ettus Research LLC
+ *
+ * Author: Tom Tsou <tom@tsou.cc>
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * 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 Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ * See the COPYING file in the main directory for details.
+ */
+
+#include <string.h>
+#include <iostream>
+#include "radioBuffer.h"
+
+RadioBuffer::RadioBuffer(size_t numSegments, size_t segmentLen,
+			 size_t hLen, bool outDirection)
+	: writeIndex(0), readIndex(0), availSamples(0)
+{
+	if (!outDirection)
+		hLen = 0;
+
+	buffer = new float[2 * (hLen + numSegments * segmentLen)];
+	bufferLen = numSegments * segmentLen;
+
+	segments.resize(numSegments);
+
+	for (size_t i = 0; i < numSegments; i++)
+		segments[i] = &buffer[2 * (hLen + i * segmentLen)];
+
+	this->outDirection = outDirection;
+	this->numSegments = numSegments;
+	this->segmentLen = segmentLen;
+	this->hLen = hLen;
+}
+
+RadioBuffer::~RadioBuffer()
+{
+	delete[] buffer;
+}
+
+void RadioBuffer::reset()
+{
+	writeIndex = 0;
+	readIndex = 0;
+	availSamples = 0;
+}
+
+/*
+ * Output direction
+ *
+ * Return a pointer to the oldest segment or NULL if a complete segment is not
+ * available.
+ */
+const float *RadioBuffer::getReadSegment()
+{
+	if (!outDirection) {
+		std::cout << "Invalid direction" << std::endl;
+		return NULL;
+	}
+	if (availSamples < segmentLen) {
+		std::cout << "Not enough samples " << std::endl;
+		std::cout << availSamples << " available per segment "
+			  << segmentLen << std::endl;
+		return NULL;
+	}
+
+	size_t num = readIndex / segmentLen;
+
+	if (num >= numSegments) {
+		std::cout << "Invalid segment" << std::endl;
+		return NULL;
+	} else if (!num) {
+		memcpy(buffer,
+		       &buffer[2 * bufferLen],
+		       hLen * 2 * sizeof(float));
+	}
+
+	availSamples -= segmentLen;
+	readIndex = (readIndex + segmentLen) % bufferLen;
+
+	return segments[num];
+}
+
+/*
+ * Output direction
+ *
+ * Write a non-segment length of samples to the buffer. 
+ */
+bool RadioBuffer::write(const float *wr, size_t len)
+{
+	if (!outDirection) {
+		std::cout << "Invalid direction" << std::endl;
+		return false;
+	}
+	if (availSamples + len > bufferLen) {
+		std::cout << "Insufficient space" << std::endl;
+		std::cout << bufferLen - availSamples << " available per write "
+			  << len << std::endl;
+		return false;
+	}
+
+	if (writeIndex + len <= bufferLen) {
+		memcpy(&buffer[2 * (writeIndex + hLen)],
+		       wr, len * 2 * sizeof(float));
+	} else {
+		size_t len0 = bufferLen - writeIndex;
+		size_t len1 = len - len0;
+		memcpy(&buffer[2 * (writeIndex + hLen)], wr, len0 * 2 * sizeof(float));
+		memcpy(&buffer[2 * hLen], &wr[2 * len0], len1 * 2 * sizeof(float));
+	}
+
+	availSamples += len;
+	writeIndex = (writeIndex + len) % bufferLen;
+
+	return true;
+}
+
+bool RadioBuffer::zero(size_t len)
+{
+	if (!outDirection) {
+		std::cout << "Invalid direction" << std::endl;
+		return false;
+	}
+	if (availSamples + len > bufferLen) {
+		std::cout << "Insufficient space" << std::endl;
+		std::cout << bufferLen - availSamples << " available per zero "
+			  << len << std::endl;
+		return false;
+	}
+
+	if (writeIndex + len <= bufferLen) {
+		memset(&buffer[2 * (writeIndex + hLen)],
+		       0, len * 2 * sizeof(float));
+	} else {
+		size_t len0 = bufferLen - writeIndex;
+		size_t len1 = len - len0;
+		memset(&buffer[2 * (writeIndex + hLen)], 0, len0 * 2 * sizeof(float));
+		memset(&buffer[2 * hLen], 0, len1 * 2 * sizeof(float));
+	}
+
+	availSamples += len;
+	writeIndex = (writeIndex + len) % bufferLen;
+
+	return true;
+}
+
+/*
+ * Input direction
+ */
+float *RadioBuffer::getWriteSegment()
+{
+	if (outDirection) {
+		std::cout << "Invalid direction" << std::endl;
+		return NULL;
+	}
+	if (bufferLen - availSamples < segmentLen) {
+		std::cout << "Insufficient samples" << std::endl;
+		std::cout << bufferLen - availSamples
+			  << " available for segment " << segmentLen
+			  << std::endl;
+		return NULL;
+	}
+	if (writeIndex % segmentLen) {
+		std::cout << "Internal segment error" << std::endl;
+		return NULL;
+	}
+
+	size_t num = writeIndex / segmentLen;
+
+	if (num >= numSegments)
+		return NULL;
+
+	availSamples += segmentLen;
+	writeIndex = (writeIndex + segmentLen) % bufferLen;
+
+	return segments[num];
+}
+
+bool RadioBuffer::zeroWriteSegment()
+{
+	float *segment = getWriteSegment();
+	if (!segment)
+		return false;
+
+	memset(segment, 0, segmentLen * 2 * sizeof(float));
+
+	return true;
+}
+
+bool RadioBuffer::read(float *rd, size_t len)
+{
+	if (outDirection) {
+		std::cout << "Invalid direction" << std::endl;
+		return false;
+	}
+	if (availSamples < len) {
+		std::cout << "Insufficient samples" << std::endl;
+		std::cout << availSamples << " available for "
+			  << len << std::endl;
+		return false;
+	}
+
+	if (readIndex + len <= bufferLen) {
+		memcpy(rd, &buffer[2 * readIndex], len * 2 * sizeof(float));
+	} else {
+		size_t len0 = bufferLen - readIndex;
+		size_t len1 = len - len0;
+		memcpy(rd, &buffer[2 * readIndex], len0 * 2 * sizeof(float));
+		memcpy(&rd[2 * len0], buffer, len1 * 2 * sizeof(float));
+	}
+
+	availSamples -= len;
+	readIndex = (readIndex + len) % bufferLen;
+
+	return true;
+}

Transceiver52M/radioBuffer.h

@@ -0,0 +1,45 @@
+#include <stdlib.h>
+#include <stddef.h>
+#include <vector>
+
+class RadioBuffer {
+public:
+	RadioBuffer(size_t numSegments, size_t segmentLen,
+		    size_t hLen, bool outDirection);
+
+	~RadioBuffer();
+
+	const size_t getSegmentLen() { return segmentLen; }
+	const size_t getNumSegments() { return numSegments; }
+	const size_t getAvailSamples() { return availSamples; }
+	const size_t getAvailSegments() { return availSamples / segmentLen; }
+
+	const size_t getFreeSamples()
+	{
+		return bufferLen - availSamples;
+	}
+
+	const size_t getFreeSegments()
+	{
+		return getFreeSamples() / segmentLen;
+	}
+
+	void reset();
+
+	/* Output direction */
+	const float *getReadSegment();
+	bool write(const float *wr, size_t len);
+	bool zero(size_t len);
+
+	/* Input direction */
+	float *getWriteSegment();
+	bool zeroWriteSegment();
+	bool read(float *rd, size_t len);
+
+private:
+	size_t writeIndex, readIndex, availSamples;
+	size_t bufferLen, numSegments, segmentLen, hLen;
+	float *buffer;
+	std::vector<float *> segments;
+	bool outDirection;
+};

Transceiver52M/radioDevice.h

@@ -23,6 +23,7 @@
 #endif
 
 #define GSMRATE       (1625e3/6)
+#define MCBTS_SPACING  800000.0
 
 /** a 64-bit virtual timestamp for radio data */
 typedef unsigned long long TIMESTAMP;
@@ -35,13 +36,24 @@ class RadioDevice {
   enum TxWindowType { TX_WINDOW_USRP1, TX_WINDOW_FIXED };
 
   /* Radio interface types */
-  enum RadioInterfaceType { NORMAL, RESAMP_64M, RESAMP_100M, DIVERSITY };
+  enum InterfaceType {
+    NORMAL,
+    RESAMP_64M,
+    RESAMP_100M,
+    MULTI_ARFCN,
+  };
 
-  static RadioDevice *make(size_t tx_sps, size_t rx_sps = 1, size_t chans = 1,
-                           bool diversity = false, double offset = 0.0);
+  enum ReferenceType {
+    REF_INTERNAL,
+    REF_EXTERNAL,
+    REF_GPS,
+  };
+
+  static RadioDevice *make(size_t tx_sps, size_t rx_sps, InterfaceType type,
+                           size_t chans = 1, double offset = 0.0);
 
   /** Initialize the USRP */
-  virtual int open(const std::string &args = "", bool extref = false, bool swap_channels = false)=0;
+  virtual int open(const std::string &args, int ref, bool swap_channels)=0;
 
   virtual ~RadioDevice() { }
 

Transceiver52M/radioInterface.cpp

@@ -1,30 +1,28 @@
 /*
-* Copyright 2008, 2009 Free Software Foundation, Inc.
-*
-* This software is distributed under the terms of the GNU Affero Public License.
-* See the COPYING file in the main directory for details.
-*
-* This use of this software may be subject to additional restrictions.
-* See the LEGAL file in the main directory for details.
-
-	This program is free software: you can redistribute it and/or modify
-	it under the terms of the GNU Affero General Public License as published by
-	the Free Software Foundation, either version 3 of the License, or
-	(at your option) any later version.
-
-	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 Affero General Public License for more details.
-
-	You should have received a copy of the GNU Affero General Public License
-	along with this program.  If not, see <http://www.gnu.org/licenses/>.
-
-*/
+ * Radio device interface
+ *
+ * Copyright (C) 2008-2014 Free Software Foundation, Inc.
+ * Copyright (C) 2015 Ettus Research LLC
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * 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 Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ * See the COPYING file in the main directory for details.
+ */
 
 #include "radioInterface.h"
 #include "Resampler.h"
 #include <Logger.h>
+#include <PRBS.h>
 
 extern "C" {
 #include "convert.h"
@@ -34,11 +32,10 @@ extern "C" {
 #define NUMCHUNKS	4
 
 RadioInterface::RadioInterface(RadioDevice *wRadio, size_t tx_sps,
-                               size_t rx_sps, size_t chans, size_t diversity,
+                               size_t rx_sps, size_t chans,
                                int wReceiveOffset, GSM::Time wStartTime)
   : mRadio(wRadio), mSPSTx(tx_sps), mSPSRx(rx_sps), mChans(chans),
-    mMIMO(diversity), sendCursor(0), recvCursor(0), underrun(false),
-    overrun(false), receiveOffset(wReceiveOffset), mOn(false)
+    underrun(false), overrun(false), receiveOffset(wReceiveOffset), mOn(false)
 {
   mClock.set(wStartTime);
 }
@@ -50,7 +47,7 @@ RadioInterface::~RadioInterface(void)
 
 bool RadioInterface::init(int type)
 {
-  if ((type != RadioDevice::NORMAL) || (mMIMO > 1) || !mChans) {
+  if ((type != RadioDevice::NORMAL) || !mChans) {
     LOG(ALERT) << "Invalid configuration";
     return false;
   }
@@ -65,35 +62,20 @@ bool RadioInterface::init(int type)
   powerScaling.resize(mChans);
 
   for (size_t i = 0; i < mChans; i++) {
-    sendBuffer[i] = new signalVector(CHUNK * mSPSTx);
-    recvBuffer[i] = new signalVector(NUMCHUNKS * CHUNK * mSPSRx);
+    sendBuffer[i] = new RadioBuffer(NUMCHUNKS, CHUNK * mSPSTx, 0, true);
+    recvBuffer[i] = new RadioBuffer(NUMCHUNKS, CHUNK * mSPSRx, 0, false);
 
-    convertSendBuffer[i] = new short[sendBuffer[i]->size() * 2];
-    convertRecvBuffer[i] = new short[recvBuffer[i]->size() * 2];
+    convertSendBuffer[i] = new short[CHUNK * mSPSTx * 2];
+    convertRecvBuffer[i] = new short[CHUNK * mSPSRx * 2];
 
     powerScaling[i] = 1.0;
   }
 
-  sendCursor = 0;
-  recvCursor = 0;
-
   return true;
 }
 
 void RadioInterface::close()
 {
-  for (size_t i = 0; i < sendBuffer.size(); i++)
-    delete sendBuffer[i];
-
-  for (size_t i = 0; i < recvBuffer.size(); i++)
-    delete recvBuffer[i];
-
-  for (size_t i = 0; i < convertSendBuffer.size(); i++)
-    delete convertSendBuffer[i];
-
-  for (size_t i = 0; i < convertRecvBuffer.size(); i++)
-    delete convertRecvBuffer[i];
-
   sendBuffer.resize(0);
   recvBuffer.resize(0);
   convertSendBuffer.resize(0);
@@ -132,35 +114,26 @@ int RadioInterface::setPowerAttenuation(int atten, size_t chan)
 }
 
 int RadioInterface::radioifyVector(signalVector &wVector,
-				   float *retVector,
-				   bool zero)
+                                   size_t chan, bool zero)
 {
-  if (zero) {
-    memset(retVector, 0, wVector.size() * 2 * sizeof(float));
-    return wVector.size();
-  }
-
-  memcpy(retVector, wVector.begin(), wVector.size() * 2 * sizeof(float));
+  if (zero)
+    sendBuffer[chan]->zero(wVector.size());
+  else
+    sendBuffer[chan]->write((float *) wVector.begin(), wVector.size());
 
   return wVector.size();
 }
 
-int RadioInterface::unRadioifyVector(float *floatVector,
-				     signalVector& newVector)
+int RadioInterface::unRadioifyVector(signalVector *newVector, size_t chan)
 {
-  signalVector::iterator itr = newVector.begin();
-
-  if (newVector.size() > recvCursor) {
+  if (newVector->size() > recvBuffer[chan]->getAvailSamples()) {
     LOG(ALERT) << "Insufficient number of samples in receive buffer";
     return -1;
   }
 
-  for (size_t i = 0; i < newVector.size(); i++) {
-    *itr++ = Complex<float>(floatVector[2 * i + 0],
-			    floatVector[2 * i + 1]);
-  }
+  recvBuffer[chan]->read((float *) newVector->begin(), newVector->size());
 
-  return newVector.size();
+  return newVector->size();
 }
 
 bool RadioInterface::tuneTx(double freq, size_t chan)
@@ -187,8 +160,10 @@ bool RadioInterface::start()
   if (!mRadio->start())
     return false;
 
-  recvCursor = 0;
-  sendCursor = 0;
+  for (size_t i = 0; i < mChans; i++) {
+    sendBuffer[i]->reset();
+    recvBuffer[i]->reset();
+  }
 
   writeTimestamp = mRadio->initialWriteTimestamp();
   readTimestamp = mRadio->initialReadTimestamp();
@@ -239,14 +214,10 @@ void RadioInterface::driveTransmitRadio(std::vector<signalVector *> &bursts,
   if (!mOn)
     return;
 
-  for (size_t i = 0; i < mChans; i++) {
-    radioifyVector(*bursts[i],
-                   (float *) (sendBuffer[i]->begin() + sendCursor), zeros[i]);
-  }
+  for (size_t i = 0; i < mChans; i++)
+    radioifyVector(*bursts[i], i, zeros[i]);
 
-  sendCursor += bursts[0]->size();
-
-  pushBuffer();
+  while (pushBuffer());
 }
 
 bool RadioInterface::driveReceiveRadio()
@@ -261,8 +232,7 @@ bool RadioInterface::driveReceiveRadio()
   GSM::Time rcvClock = mClock.get();
   rcvClock.decTN(receiveOffset);
   unsigned tN = rcvClock.TN();
-  int recvSz = recvCursor;
-  int readSz = 0;
+  int recvSz = recvBuffer[0]->getAvailSamples();
   const int symbolsPerSlot = gSlotLen + 8;
   int burstSize;
 
@@ -283,13 +253,8 @@ bool RadioInterface::driveReceiveRadio()
    */
   while (recvSz > burstSize) {
     for (size_t i = 0; i < mChans; i++) {
-      burst = new radioVector(rcvClock, burstSize, head, mMIMO);
-
-      for (size_t n = 0; n < mMIMO; n++) {
-        unRadioifyVector((float *)
-                         (recvBuffer[mMIMO * i + n]->begin() + readSz),
-                         *burst->getVector(n));
-      }
+      burst = new radioVector(rcvClock, burstSize, head);
+      unRadioifyVector(burst->getVector(), i);
 
       if (mReceiveFIFO[i].size() < 32)
         mReceiveFIFO[i].write(burst);
@@ -299,7 +264,6 @@ bool RadioInterface::driveReceiveRadio()
 
     mClock.incTN();
     rcvClock.incTN();
-    readSz += burstSize;
     recvSz -= burstSize;
 
     tN = rcvClock.TN();
@@ -308,16 +272,6 @@ bool RadioInterface::driveReceiveRadio()
       burstSize = (symbolsPerSlot + (tN % 4 == 0)) * mSPSRx;
   }
 
-  if (readSz > 0) {
-    for (size_t i = 0; i < recvBuffer.size(); i++) {
-      memmove(recvBuffer[i]->begin(),
-              recvBuffer[i]->begin() + readSz,
-              (recvCursor - readSz) * 2 * sizeof(float));
-    }
-
-    recvCursor -= readSz;
-  }
-
   return true;
 }
 
@@ -339,74 +293,66 @@ VectorFIFO* RadioInterface::receiveFIFO(size_t chan)
 
 double RadioInterface::setRxGain(double dB, size_t chan)
 {
-  if (mRadio)
-    return mRadio->setRxGain(dB, chan);
-  else
-    return -1;
+  return mRadio->setRxGain(dB, chan);
 }
 
 double RadioInterface::getRxGain(size_t chan)
 {
-  if (mRadio)
-    return mRadio->getRxGain(chan);
-  else
-    return -1;
+  return mRadio->getRxGain(chan);
 }
 
 /* Receive a timestamped chunk from the device */
 void RadioInterface::pullBuffer()
 {
   bool local_underrun;
-  int num_recv;
-  float *output;
+  size_t numRecv, segmentLen = recvBuffer[0]->getSegmentLen();
 
-  if (recvCursor > recvBuffer[0]->size() - CHUNK)
+  if (recvBuffer[0]->getFreeSegments() <= 0)
     return;
 
   /* Outer buffer access size is fixed */
-  num_recv = mRadio->readSamples(convertRecvBuffer,
-                                 CHUNK,
-                                 &overrun,
-                                 readTimestamp,
-                                 &local_underrun);
-  if (num_recv != CHUNK) {
-          LOG(ALERT) << "Receive error " << num_recv;
+  numRecv = mRadio->readSamples(convertRecvBuffer,
+                                segmentLen,
+                                &overrun,
+                                readTimestamp,
+                                &local_underrun);
+
+  if (numRecv != segmentLen) {
+          LOG(ALERT) << "Receive error " << numRecv;
           return;
   }
 
   for (size_t i = 0; i < mChans; i++) {
-    output = (float *) (recvBuffer[i]->begin() + recvCursor);
-    convert_short_float(output, convertRecvBuffer[i], 2 * num_recv);
+    convert_short_float(recvBuffer[i]->getWriteSegment(),
+			convertRecvBuffer[i],
+			segmentLen * 2);
   }
 
   underrun |= local_underrun;
-
-  readTimestamp += num_recv;
-  recvCursor += num_recv;
+  readTimestamp += numRecv;
 }
 
 /* Send timestamped chunk to the device with arbitrary size */
-void RadioInterface::pushBuffer()
+bool RadioInterface::pushBuffer()
 {
-  int num_sent;
+  size_t numSent, segmentLen = sendBuffer[0]->getSegmentLen();
 
-  if (sendCursor < CHUNK)
-    return;
-
-  if (sendCursor > sendBuffer[0]->size())
-    LOG(ALERT) << "Send buffer overflow";
+  if (sendBuffer[0]->getAvailSegments() < 1)
+    return false;
 
   for (size_t i = 0; i < mChans; i++) {
     convert_float_short(convertSendBuffer[i],
-                        (float *) sendBuffer[i]->begin(),
-                        powerScaling[i], 2 * sendCursor);
+                        (float *) sendBuffer[i]->getReadSegment(),
+                        powerScaling[i],
+                        segmentLen * 2);
   }
 
-  /* Send the all samples in the send buffer */ 
-  num_sent = mRadio->writeSamples(convertSendBuffer,
-                                  sendCursor,
-                                  &underrun,
-                                  writeTimestamp);
-  writeTimestamp += num_sent;
-  sendCursor = 0;
+  /* Send the all samples in the send buffer */
+  numSent = mRadio->writeSamples(convertSendBuffer,
+                                 segmentLen,
+                                 &underrun,
+                                 writeTimestamp);
+  writeTimestamp += numSent;
+
+  return true;
 }

Transceiver52M/radioInterface.h

@@ -20,7 +20,10 @@
 #include "radioDevice.h"
 #include "radioVector.h"
 #include "radioClock.h"
+#include "radioBuffer.h"
 #include "Resampler.h"
+#include "Channelizer.h"
+#include "Synthesis.h"
 
 static const unsigned gSlotLen = 148;      ///< number of symbols per slot, not counting guard periods
 
@@ -38,12 +41,9 @@ protected:
   size_t mSPSTx;
   size_t mSPSRx;
   size_t mChans;
-  size_t mMIMO;
 
-  std::vector<signalVector *> sendBuffer;
-  std::vector<signalVector *> recvBuffer;
-  unsigned sendCursor;
-  unsigned recvCursor;
+  std::vector<RadioBuffer *> sendBuffer;
+  std::vector<RadioBuffer *> recvBuffer;
 
   std::vector<short *> convertRecvBuffer;
   std::vector<short *> convertSendBuffer;
@@ -61,16 +61,14 @@ protected:
 
 private:
 
-  /** format samples to USRP */ 
-  int radioifyVector(signalVector &wVector,
-                     float *floatVector,
-                     bool zero);
+  /** format samples to USRP */
+  int radioifyVector(signalVector &wVector, size_t chan, bool zero);
 
   /** format samples from USRP */
-  int unRadioifyVector(float *floatVector, signalVector &wVector);
+  int unRadioifyVector(signalVector *wVector, size_t chan);
 
   /** push GSM bursts into the transmit buffer */
-  virtual void pushBuffer(void);
+  virtual bool pushBuffer(void);
 
   /** pull GSM bursts from the receive buffer */
   virtual void pullBuffer(void);
@@ -86,10 +84,9 @@ public:
   virtual void close();
 
   /** constructor */
-  RadioInterface(RadioDevice* wRadio = NULL,
-                 size_t tx_sps = 4, size_t rx_sps = 1,
-		 size_t chans = 1, size_t diversity = 1,
-                 int receiveOffset = 3, GSM::Time wStartTime = GSM::Time(0));
+  RadioInterface(RadioDevice* wRadio, size_t tx_sps, size_t rx_sps,
+                 size_t chans = 1, int receiveOffset = 3,
+                 GSM::Time wStartTime = GSM::Time(0));
 
   /** destructor */
   virtual ~RadioInterface();
@@ -104,7 +101,7 @@ public:
   RadioClock* getClock(void) { return &mClock;};
 
   /** set transmit frequency */
-  bool tuneTx(double freq, size_t chan = 0);
+  virtual bool tuneTx(double freq, size_t chan = 0);
 
   /** set receive frequency */
   virtual bool tuneRx(double freq, size_t chan = 0);
@@ -152,45 +149,45 @@ void *AlignRadioServiceLoopAdapter(RadioInterface*);
 #endif
 
 class RadioInterfaceResamp : public RadioInterface {
-
 private:
-  signalVector *innerSendBuffer;
   signalVector *outerSendBuffer;
-  signalVector *innerRecvBuffer;
   signalVector *outerRecvBuffer;
 
-  void pushBuffer();
+  bool pushBuffer();
   void pullBuffer();
 
 public:
-
-  RadioInterfaceResamp(RadioDevice* wRadio, size_t wSPS = 4, size_t chans = 1);
-
+  RadioInterfaceResamp(RadioDevice* wRadio, size_t tx_sps, size_t rx_sps);
   ~RadioInterfaceResamp();
 
   bool init(int type);
   void close();
 };
 
-class RadioInterfaceDiversity : public RadioInterface {
-public:
-  RadioInterfaceDiversity(RadioDevice* wRadio,
-                          size_t sps = 4, size_t chans = 2);
+class RadioInterfaceMulti : public RadioInterface {
+private:
+  bool pushBuffer();
+  void pullBuffer();
 
-  ~RadioInterfaceDiversity();
+  signalVector *outerSendBuffer;
+  signalVector *outerRecvBuffer;
+  std::vector<signalVector *> history;
+  std::vector<bool> active;
+
+  Resampler *dnsampler;
+  Resampler *upsampler;
+  Channelizer *channelizer;
+  Synthesis *synthesis;
+
+public:
+  RadioInterfaceMulti(RadioDevice* radio, size_t tx_sps,
+                      size_t rx_sps, size_t chans = 1);
+  ~RadioInterfaceMulti();
 
   bool init(int type);
   void close();
+
+  bool tuneTx(double freq, size_t chan);
   bool tuneRx(double freq, size_t chan);
-
-private:
-  std::vector<Resampler *> dnsamplers;
-  std::vector<float> phases;
-  signalVector *outerRecvBuffer;
-
-  bool mDiversity;
-  double mFreqSpacing;
-
-  bool setupDiversityChannels();
-  void pullBuffer();
+  double setRxGain(double dB, size_t chan);
 };

Transceiver52M/radioInterfaceDiversity.cpp

@@ -1,248 +0,0 @@
-/*
- * SSE Convolution
- * Copyright (C) 2013 Thomas Tsou <tom@tsou.cc>
- *
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2.1 of the License, or (at your option) any later version.
- *
- * This library 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
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
- */
-
-#include <radioInterface.h>
-#include <Logger.h>
-
-#include "Resampler.h"
-
-extern "C" {
-#include "convert.h"
-}
-
-/* Resampling parameters for 64 MHz clocking */
-#define RESAMP_64M_INRATE			20
-#define RESAMP_64M_OUTRATE			80
-
-/* Downlink block size */
-#define CHUNK					625
-
-/* Universal resampling parameters */
-#define NUMCHUNKS				48
-
-/*
- * Resampling filter bandwidth scaling factor
- *   This narrows the filter cutoff relative to the output bandwidth
- *   of the polyphase resampler. At 4 samples-per-symbol using the
- *   2 pulse Laurent GMSK approximation gives us below 0.5 degrees
- *   RMS phase error at the resampler output.
- */
-#define RESAMP_TX4_FILTER		0.45
-
-static size_t resamp_inrate = 0;
-static size_t resamp_inchunk = 0;
-static size_t resamp_outrate = 0;
-static size_t resamp_outchunk = 0;
-
-RadioInterfaceDiversity::RadioInterfaceDiversity(RadioDevice *wRadio,
-						 size_t sps, size_t chans)
-	: RadioInterface(wRadio, sps, chans, 2), outerRecvBuffer(NULL),
-	  mDiversity(false), mFreqSpacing(0.0)
-{
-}
-
-RadioInterfaceDiversity::~RadioInterfaceDiversity()
-{
-	close();
-}
-
-void RadioInterfaceDiversity::close()
-{
-	delete outerRecvBuffer;
-
-	outerRecvBuffer = NULL;
-
-	for (size_t i = 0; i < dnsamplers.size(); i++) {
-		delete dnsamplers[i];
-		dnsamplers[i] = NULL;
-	}
-
-	if (recvBuffer.size())
-		recvBuffer[0] = NULL;
-
-	RadioInterface::close();
-}
-
-bool RadioInterfaceDiversity::setupDiversityChannels()
-{
-	size_t inner_rx_len;
-
-	/* Inner and outer rates */
-	resamp_inrate = RESAMP_64M_INRATE;
-	resamp_outrate = RESAMP_64M_OUTRATE;
-	resamp_inchunk = resamp_inrate * 4;
-	resamp_outchunk = resamp_outrate * 4;
-
-	/* Buffer lengths */
-	inner_rx_len = NUMCHUNKS * resamp_inchunk;
-
-	/* Inside buffer must hold at least 2 bursts */
-	if (inner_rx_len < 157 * mSPSRx * 2) {
-		LOG(ALERT) << "Invalid inner buffer size " << inner_rx_len;
-		return false;
-	}
-
-	/* One Receive buffer and downsampler per diversity channel */
-	for (size_t i = 0; i < mMIMO * mChans; i++) {
-		dnsamplers[i] = new Resampler(resamp_inrate, resamp_outrate);
-		if (!dnsamplers[i]->init()) {
-			LOG(ALERT) << "Rx resampler failed to initialize";
-			return false;
-		}
-
-		recvBuffer[i] = new signalVector(inner_rx_len);
-	}
-
-	return true;
-}
-
-/* Initialize I/O specific objects */
-bool RadioInterfaceDiversity::init(int type)
-{
-	int tx_len, outer_rx_len;
-
-	if ((mMIMO != 2) || (mChans != 2)) {
-		LOG(ALERT) << "Unsupported channel configuration " << mChans;
-		return false;
-	}
-
-	/* Resize for channel combination */
-	sendBuffer.resize(mChans);
-	recvBuffer.resize(mChans * mMIMO);
-	convertSendBuffer.resize(mChans);
-	convertRecvBuffer.resize(mChans);
-	mReceiveFIFO.resize(mChans);
-	dnsamplers.resize(mChans * mMIMO);
-	phases.resize(mChans);
-
-	if (!setupDiversityChannels())
-		return false;
-
-	tx_len = CHUNK * mSPSTx;
-	outer_rx_len = resamp_outchunk;
-
-	for (size_t i = 0; i < mChans; i++) {
-		/* Full rate float and integer outer receive buffers */
-		convertRecvBuffer[i] = new short[outer_rx_len * 2];
-
-		/* Send buffers (not-resampled) */
-		sendBuffer[i] = new signalVector(tx_len);
-		convertSendBuffer[i] = new short[tx_len * 2];
-	}
-
-	outerRecvBuffer = new signalVector(outer_rx_len, dnsamplers[0]->len());
-
-	return true;
-}
-
-bool RadioInterfaceDiversity::tuneRx(double freq, size_t chan)
-{
-	double f0, f1;
-
-	if (chan > 1)
-		return false;
-
-	if (!mRadio->setRxFreq(freq, chan))
-		return false;
-
-	f0 = mRadio->getRxFreq(0);
-	f1 = mRadio->getRxFreq(1);
-
-	mFreqSpacing = f1 - f0;
-
-	if (abs(mFreqSpacing) <= 600e3)
-		mDiversity = true;
-	else
-		mDiversity = false;
-
-	return true;
-}
-
-/* Receive a timestamped chunk from the device */
-void RadioInterfaceDiversity::pullBuffer()
-{
-	bool local_underrun;
-	int rc, num, path0, path1;
-	signalVector *shift, *base;
-	float *in, *out, rate = -mFreqSpacing * 2.0 * M_PI / 1.08333333e6;
-
-	if (recvCursor > recvBuffer[0]->size() - resamp_inchunk)
-		return;
-
-	/* Outer buffer access size is fixed */
-	num = mRadio->readSamples(convertRecvBuffer,
-				  resamp_outchunk,
-				  &overrun,
-				  readTimestamp,
-				  &local_underrun);
-	if ((size_t) num != resamp_outchunk) {
-		LOG(ALERT) << "Receive error " << num;
-		return;
-	}
-
-	for (size_t i = 0; i < mChans; i++) {
-		convert_short_float((float *) outerRecvBuffer->begin(),
-			    convertRecvBuffer[i], 2 * resamp_outchunk);
-
-		if (!i) {
-			path0 = 0;
-			path1 = 2;
-		} else {
-			path0 = 3;
-			path1 = 1;
-		}
-
-		/* Diversity path 1 */
-		base = outerRecvBuffer;
-		in = (float *) base->begin();
-		out = (float *) (recvBuffer[path0]->begin() + recvCursor);
-
-		rc = dnsamplers[2 * i + 0]->rotate(in, resamp_outchunk,
-						   out, resamp_inchunk);
-		if (rc < 0) {
-			LOG(ALERT) << "Sample rate downsampling error";
-		}
-
-		/* Enable path 2 if Nyquist bandwidth is sufficient */
-		if (!mDiversity)
-			continue;
-
-		/* Diversity path 2 */
-		shift = new signalVector(base->size(), base->getStart());
-		in = (float *) shift->begin();
-		out = (float *) (recvBuffer[path1]->begin() + recvCursor);
-
-		rate = i ? -rate : rate;
-		if (!frequencyShift(shift, base, rate, phases[i], &phases[i])) {
-			LOG(ALERT) << "Frequency shift failed";
-		}
-
-		rc = dnsamplers[2 * i + 1]->rotate(in, resamp_outchunk,
-						   out, resamp_inchunk);
-		if (rc < 0) {
-			LOG(ALERT) << "Sample rate downsampling error";
-		}
-
-		delete shift;
-	}
-
-	underrun |= local_underrun;
-	readTimestamp += (TIMESTAMP) resamp_outchunk;
-	recvCursor += resamp_inchunk;
-}

Transceiver52M/radioInterfaceMulti.cpp

@@ -0,0 +1,391 @@
+/*
+ * Multi-carrier radio interface
+ *
+ * Copyright (C) 2016 Ettus Research LLC 
+ *
+ * Author: Tom Tsou <tom.tsou@ettus.com>
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * 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 Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ * See the COPYING file in the main directory for details.
+ */
+
+#include <radioInterface.h>
+#include <Logger.h>
+
+#include "Resampler.h"
+
+extern "C" {
+#include "convert.h"
+}
+
+/* Resampling parameters for 64 MHz clocking */
+#define RESAMP_INRATE			65
+#define RESAMP_OUTRATE			(96 / 2)
+
+/* Universal resampling parameters */
+#define NUMCHUNKS				24
+
+#define MCHANS					4
+
+RadioInterfaceMulti::RadioInterfaceMulti(RadioDevice *radio, size_t tx_sps,
+					 size_t rx_sps, size_t chans)
+	: RadioInterface(radio, tx_sps, rx_sps, chans),
+	  outerSendBuffer(NULL), outerRecvBuffer(NULL),
+	  dnsampler(NULL), upsampler(NULL), channelizer(NULL), synthesis(NULL)
+{
+}
+
+RadioInterfaceMulti::~RadioInterfaceMulti()
+{
+	close();
+}
+
+void RadioInterfaceMulti::close()
+{
+	delete outerSendBuffer;
+	delete outerRecvBuffer;
+	delete dnsampler;
+	delete upsampler;
+	delete channelizer;
+	delete synthesis;
+
+	outerSendBuffer = NULL;
+	outerRecvBuffer = NULL;
+	dnsampler = NULL;
+	upsampler = NULL;
+	channelizer = NULL;
+	synthesis = NULL;
+
+	mReceiveFIFO.resize(0);
+	powerScaling.resize(0);
+	history.resize(0);
+	active.resize(0);
+
+	RadioInterface::close();
+}
+
+static int getLogicalChan(size_t pchan, size_t chans)
+{
+	switch (chans) {
+	case 1:
+		if (pchan == 0)
+			return 0;
+		else
+			return -1;
+		break;
+	case 2:
+		if (pchan == 0)
+			return 0;
+		if (pchan == 3)
+			return 1;
+		else
+			return -1;
+		break;
+	case 3:
+		if (pchan == 1)
+			return 0;
+		if (pchan == 0)
+			return 1;
+		if (pchan == 3)
+			return 2;
+		else
+			return -1;
+		break;
+	default:
+		break;
+	};
+
+	return -1;
+}
+
+static int getFreqShift(size_t chans)
+{
+	switch (chans) {
+	case 1:
+		return 0;
+	case 2:
+		return 0;
+	case 3:
+		return 1;
+	default:
+		break;
+	};
+
+	return -1;
+}
+
+/* Initialize I/O specific objects */
+bool RadioInterfaceMulti::init(int type)
+{
+	float cutoff = 1.0f;
+	size_t inchunk = 0, outchunk = 0;
+
+	if (mChans > MCHANS - 1) {
+		LOG(ALERT) << "Invalid channel configuration " << mChans;
+		return false;
+	}
+
+	close();
+
+	sendBuffer.resize(mChans);
+	recvBuffer.resize(mChans);
+	convertSendBuffer.resize(1);
+	convertRecvBuffer.resize(1);
+
+	mReceiveFIFO.resize(mChans);
+	powerScaling.resize(mChans);
+	history.resize(mChans);
+	active.resize(MCHANS, false);
+
+	inchunk = RESAMP_INRATE * 4;
+	outchunk = RESAMP_OUTRATE * 4;
+
+	if (inchunk  * NUMCHUNKS < 625 * 2) {
+		LOG(ALERT) << "Invalid inner chunk size " << inchunk;
+		return false;
+	}
+
+	dnsampler = new Resampler(RESAMP_INRATE, RESAMP_OUTRATE);
+	if (!dnsampler->init(1.0)) {
+		LOG(ALERT) << "Rx resampler failed to initialize";
+		return false;
+	}
+
+	upsampler = new Resampler(RESAMP_OUTRATE, RESAMP_INRATE);
+	if (!upsampler->init(cutoff)) {
+		LOG(ALERT) << "Tx resampler failed to initialize";
+		return false;
+	}
+
+	channelizer = new Channelizer(MCHANS, outchunk);
+	if (!channelizer->init()) {
+		LOG(ALERT) << "Rx channelizer failed to initialize";
+		return false;
+	}
+
+	synthesis = new Synthesis(MCHANS, outchunk);
+	if (!synthesis->init()) {
+		LOG(ALERT) << "Tx synthesis filter failed to initialize";
+		return false;
+	}
+
+	/*
+	 * Allocate high and low rate buffers. The high rate receive
+	 * buffer and low rate transmit vectors feed into the resampler
+	 * and requires headroom equivalent to the filter length. Low
+	 * rate buffers are allocated in the main radio interface code.
+	 */
+	for (size_t i = 0; i < mChans; i++) {
+		sendBuffer[i] = new RadioBuffer(NUMCHUNKS, inchunk,
+					        upsampler->len(), true);
+		recvBuffer[i] = new RadioBuffer(NUMCHUNKS, inchunk,
+		                                0, false);
+		history[i] = new signalVector(dnsampler->len());
+
+		synthesis->resetBuffer(i);
+	}
+
+	outerSendBuffer = new signalVector(synthesis->outputLen());
+	outerRecvBuffer = new signalVector(channelizer->inputLen());
+
+	convertSendBuffer[0] = new short[2 * synthesis->outputLen()];
+	convertRecvBuffer[0] = new short[2 * channelizer->inputLen()];
+
+	/* Configure channels */
+	switch (mChans) {
+	case 1:
+		active[0] = true;
+		break;
+	case 2:
+		active[0] = true;
+		active[3] = true;
+		break;
+	case 3:
+		active[0] = true;
+		active[1] = true;
+		active[3] = true;
+		break;
+	default:
+		LOG(ALERT) << "Unsupported channel combination";
+		return false;
+	}
+
+	return true;
+}
+
+/* Receive a timestamped chunk from the device */
+void RadioInterfaceMulti::pullBuffer()
+{
+	bool local_underrun;
+	size_t num;
+	float *buf;
+
+	if (recvBuffer[0]->getFreeSegments() <= 0)
+		return;
+
+	/* Outer buffer access size is fixed */
+	num = mRadio->readSamples(convertRecvBuffer,
+				  outerRecvBuffer->size(),
+				  &overrun,
+				  readTimestamp,
+				  &local_underrun);
+	if (num != channelizer->inputLen()) {
+		LOG(ALERT) << "Receive error " << num << ", " << channelizer->inputLen();
+		return;
+	}
+
+	convert_short_float((float *) outerRecvBuffer->begin(),
+			    convertRecvBuffer[0], 2 * outerRecvBuffer->size());
+
+	underrun |= local_underrun;
+	readTimestamp += num;
+
+	channelizer->rotate((float *) outerRecvBuffer->begin(),
+			    outerRecvBuffer->size());
+
+	for (size_t pchan = 0; pchan < MCHANS; pchan++) {
+		if (!active[pchan])
+			continue;
+
+		int lchan = getLogicalChan(pchan, mChans);
+		if (lchan < 0) {
+			LOG(ALERT) << "Invalid logical channel " << pchan;
+			continue;
+		}
+
+		/*
+		 * Update history by writing into the head portion of the
+		 * channelizer output buffer. For this to work, filter length of
+		 * the polyphase channelizer partition filter should be equal to
+		 * or larger than the resampling filter.
+		 */
+		buf = channelizer->outputBuffer(pchan);
+		size_t cLen = channelizer->outputLen();
+		size_t hLen = dnsampler->len();
+		size_t hSize = 2 * hLen * sizeof(float);
+
+		memcpy(&buf[2 * -hLen], history[lchan]->begin(), hSize);
+		memcpy(history[lchan]->begin(), &buf[2 * (cLen - hLen)], hSize);
+
+		float *wr_segment = recvBuffer[lchan]->getWriteSegment();
+
+		/* Write to the end of the inner receive buffer */
+		if (!dnsampler->rotate(channelizer->outputBuffer(pchan),
+				       channelizer->outputLen(),
+				       wr_segment,
+				       recvBuffer[lchan]->getSegmentLen())) {
+			LOG(ALERT) << "Sample rate upsampling error";
+		}
+	}
+}
+
+/* Send a timestamped chunk to the device */
+bool RadioInterfaceMulti::pushBuffer()
+{
+	if (sendBuffer[0]->getAvailSegments() <= 0)
+		return false;
+
+	for (size_t pchan = 0; pchan < MCHANS; pchan++) {
+		if (!active[pchan]) {
+			synthesis->resetBuffer(pchan);
+			continue;
+		}
+
+		int lchan = getLogicalChan(pchan, mChans);
+		if (lchan < 0) {
+			LOG(ALERT) << "Invalid logical channel " << pchan;
+			continue;
+		}
+
+		if (!upsampler->rotate(sendBuffer[lchan]->getReadSegment(),
+				       sendBuffer[lchan]->getSegmentLen(),
+				       synthesis->inputBuffer(pchan),
+				       synthesis->inputLen())) {
+			LOG(ALERT) << "Sample rate downsampling error";
+		}
+	}
+
+	synthesis->rotate((float *) outerSendBuffer->begin(),
+			  outerSendBuffer->size());
+
+	convert_float_short(convertSendBuffer[0],
+			    (float *) outerSendBuffer->begin(),
+			    1.0 / (float) mChans, 2 * outerSendBuffer->size());
+
+	size_t num = mRadio->writeSamples(convertSendBuffer,
+					  outerSendBuffer->size(),
+					  &underrun,
+					  writeTimestamp);
+	if (num != outerSendBuffer->size()) {
+		LOG(ALERT) << "Transmit error " << num;
+	}
+
+	writeTimestamp += num;
+
+	return true;
+}
+
+/* Frequency comparison limit */
+#define FREQ_DELTA_LIMIT		10.0
+
+static bool fltcmp(double a, double b)
+{
+	return fabs(a - b) < FREQ_DELTA_LIMIT ? true : false;
+}
+
+bool RadioInterfaceMulti::tuneTx(double freq, size_t chan)
+{
+  if (chan >= mChans)
+    return false;
+
+  double shift = (double) getFreqShift(mChans);
+
+  if (!chan)
+    return mRadio->setTxFreq(freq + shift * MCBTS_SPACING);
+
+  double center = mRadio->getTxFreq();
+  if (!fltcmp(freq, center + (double) (chan - shift) * MCBTS_SPACING)) {
+    LOG(NOTICE) << "Channel " << chan << " RF frequency offset is "
+                << freq / 1e6 << " MHz";
+  }
+
+  return true;
+}
+
+bool RadioInterfaceMulti::tuneRx(double freq, size_t chan)
+{
+  if (chan >= mChans)
+    return false;
+
+  double shift = (double) getFreqShift(mChans);
+
+  if (!chan)
+    return mRadio->setRxFreq(freq + shift * MCBTS_SPACING);
+
+  double center = mRadio->getRxFreq();
+  if (!fltcmp(freq, center + (double) (chan - shift) * MCBTS_SPACING)) {
+    LOG(NOTICE) << "Channel " << chan << " RF frequency offset is "
+                << freq / 1e6 << " MHz";
+  }
+
+  return true;
+}
+
+double RadioInterfaceMulti::setRxGain(double db, size_t chan)
+{
+  if (!chan)
+    return mRadio->setRxGain(db);
+  else
+    return mRadio->getRxGain();
+}

Transceiver52M/radioInterfaceResamp.cpp

@@ -1,8 +1,10 @@
 /*
  * Radio device interface with sample rate conversion
- * Written by Thomas Tsou <tom@tsou.cc>
  *
- * Copyright 2011, 2012, 2013 Free Software Foundation, Inc.
+ * Copyright (C) 2011-2014 Free Software Foundation, Inc.
+ * Copyright (C) 2015 Ettus Research LLC
+ *
+ * Author: Tom Tsou <tom@tsou.cc>
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU Affero General Public License as published by
@@ -56,10 +58,9 @@ static size_t resamp_outrate = 0;
 static size_t resamp_outchunk = 0;
 
 RadioInterfaceResamp::RadioInterfaceResamp(RadioDevice *wRadio,
-					   size_t sps, size_t chans)
-	: RadioInterface(wRadio, sps, chans),
-	  innerSendBuffer(NULL), outerSendBuffer(NULL),
-	  innerRecvBuffer(NULL), outerRecvBuffer(NULL)
+					   size_t tx_sps, size_t rx_sps)
+	: RadioInterface(wRadio, tx_sps, rx_sps, 1),
+	  outerSendBuffer(NULL), outerRecvBuffer(NULL)
 {
 }
 
@@ -70,17 +71,13 @@ RadioInterfaceResamp::~RadioInterfaceResamp()
 
 void RadioInterfaceResamp::close()
 {
-	delete innerSendBuffer;
 	delete outerSendBuffer;
-	delete innerRecvBuffer;
 	delete outerRecvBuffer;
 
 	delete upsampler;
 	delete dnsampler;
 
-	innerSendBuffer = NULL;
 	outerSendBuffer = NULL;
-	innerRecvBuffer = NULL;
 	outerRecvBuffer = NULL;
 
 	upsampler = NULL;
@@ -99,11 +96,6 @@ bool RadioInterfaceResamp::init(int type)
 {
 	float cutoff = 1.0f;
 
-	if (mChans != 1) {
-		LOG(ALERT) << "Unsupported channel configuration " << mChans;
-		return false;
-	}
-
 	close();
 
 	sendBuffer.resize(1);
@@ -128,13 +120,8 @@ bool RadioInterfaceResamp::init(int type)
 		return false;
 	}
 
-	resamp_inchunk = resamp_inrate * 4;
-	resamp_outchunk = resamp_outrate * 4;
-
-	if (resamp_inchunk  * NUMCHUNKS < 157 * mSPSTx * 2) {
-		LOG(ALERT) << "Invalid inner chunk size " << resamp_inchunk;
-		return false;
-	}
+	resamp_inchunk = resamp_inrate * 4 * mSPSRx;
+	resamp_outchunk = resamp_outrate * 4 * mSPSRx;
 
 	if (mSPSTx == 4)
 		cutoff = RESAMP_TX4_FILTER;
@@ -157,21 +144,18 @@ bool RadioInterfaceResamp::init(int type)
 	 * and requires headroom equivalent to the filter length. Low
 	 * rate buffers are allocated in the main radio interface code.
 	 */
-	innerSendBuffer =
-		new signalVector(NUMCHUNKS * resamp_inchunk, upsampler->len());
+	sendBuffer[0] = new RadioBuffer(NUMCHUNKS, resamp_inchunk,
+					  upsampler->len(), true);
+	recvBuffer[0] = new RadioBuffer(NUMCHUNKS * 20, resamp_inchunk, 0, false);
+
 	outerSendBuffer =
 		new signalVector(NUMCHUNKS * resamp_outchunk);
 	outerRecvBuffer =
 		new signalVector(resamp_outchunk, dnsampler->len());
-	innerRecvBuffer =
-		new signalVector(NUMCHUNKS * resamp_inchunk / mSPSTx);
 
 	convertSendBuffer[0] = new short[outerSendBuffer->size() * 2];
 	convertRecvBuffer[0] = new short[outerRecvBuffer->size() * 2];
 
-	sendBuffer[0] = innerSendBuffer;
-	recvBuffer[0] = innerRecvBuffer;
-
 	return true;
 }
 
@@ -181,7 +165,7 @@ void RadioInterfaceResamp::pullBuffer()
 	bool local_underrun;
 	int rc, num_recv;
 
-	if (recvCursor > innerRecvBuffer->size() - resamp_inchunk)
+	if (recvBuffer[0]->getFreeSegments() <= 0)
 		return;
 
 	/* Outer buffer access size is fixed */
@@ -204,57 +188,47 @@ void RadioInterfaceResamp::pullBuffer()
 	/* Write to the end of the inner receive buffer */
 	rc = dnsampler->rotate((float *) outerRecvBuffer->begin(),
 			       resamp_outchunk,
-			       (float *) (innerRecvBuffer->begin() + recvCursor),
+			       recvBuffer[0]->getWriteSegment(),
 			       resamp_inchunk);
 	if (rc < 0) {
 		LOG(ALERT) << "Sample rate upsampling error";
 	}
 
-	recvCursor += resamp_inchunk;
+	/* Set history for the next chunk */
+	outerRecvBuffer->updateHistory();
 }
 
 /* Send a timestamped chunk to the device */
-void RadioInterfaceResamp::pushBuffer()
+bool RadioInterfaceResamp::pushBuffer()
 {
-	int rc, chunks, num_sent;
-	int inner_len, outer_len;
+	int rc;
+	size_t numSent;
 
-	if (sendCursor < resamp_inchunk)
-		return;
-
-	if (sendCursor > innerSendBuffer->size())
-		LOG(ALERT) << "Send buffer overflow";
-
-	chunks = sendCursor / resamp_inchunk;
-
-	inner_len = chunks * resamp_inchunk;
-	outer_len = chunks * resamp_outchunk;
+	if (sendBuffer[0]->getAvailSegments() <= 0)
+		return false;
 
 	/* Always send from the beginning of the buffer */
-	rc = upsampler->rotate((float *) innerSendBuffer->begin(), inner_len,
-			       (float *) outerSendBuffer->begin(), outer_len);
+	rc = upsampler->rotate(sendBuffer[0]->getReadSegment(),
+			       resamp_inchunk,
+			       (float *) outerSendBuffer->begin(),
+			       resamp_outchunk);
 	if (rc < 0) {
 		LOG(ALERT) << "Sample rate downsampling error";
 	}
 
 	convert_float_short(convertSendBuffer[0],
 			    (float *) outerSendBuffer->begin(),
-			    powerScaling[0], 2 * outer_len);
+			    powerScaling[0], 2 * resamp_outchunk);
 
-	num_sent = mRadio->writeSamples(convertSendBuffer,
-					outer_len,
-					&underrun,
-					writeTimestamp);
-	if (num_sent != outer_len) {
-		LOG(ALERT) << "Transmit error " << num_sent;
+	numSent = mRadio->writeSamples(convertSendBuffer,
+				       resamp_outchunk,
+				       &underrun,
+				       writeTimestamp);
+	if (numSent != resamp_outchunk) {
+		LOG(ALERT) << "Transmit error " << numSent;
 	}
 
-	/* Shift remaining samples to beginning of buffer */
-	memmove(innerSendBuffer->begin(),
-		innerSendBuffer->begin() + inner_len,
-		(sendCursor - inner_len) * 2 * sizeof(float));
+	writeTimestamp += resamp_outchunk;
 
-	writeTimestamp += outer_len;
-	sendCursor -= inner_len;
-	assert(sendCursor >= 0);
+	return true;
 }

Transceiver52M/sigProcLib.cpp

@@ -80,7 +80,6 @@ static Complex<float> psk8_table[8] = {
 #define DOWNSAMPLE_OUT_LEN	156
 
 static Resampler *dnsampler = NULL;
-static signalVector *dnsampler_in = NULL;
 
 /*
  * RACH and midamble correlation waveforms. Store the buffer separately
@@ -163,7 +162,6 @@ void sigProcLibDestroy()
   delete GSMPulse1;
   delete GSMPulse4;
   delete dnsampler;
-  delete dnsampler_in;
 
   GMSKRotation1 = NULL;
   GMSKRotation4 = NULL;
@@ -656,51 +654,6 @@ static PulseSequence *generateGSMPulse(int sps)
   return pulse;
 }
 
-signalVector* frequencyShift(signalVector *y,
-			     signalVector *x,
-			     float freq,
-			     float startPhase,
-			     float *finalPhase)
-{
-
-  if (!x) return NULL;
- 
-  if (y==NULL) {
-    y = new signalVector(x->size());
-    y->isReal(x->isReal());
-    if (y==NULL) return NULL;
-  }
-
-  if (y->size() < x->size()) return NULL;
-
-  float phase = startPhase;
-  signalVector::iterator yP = y->begin();
-  signalVector::iterator xPEnd = x->end();
-  signalVector::iterator xP = x->begin();
-
-  if (x->isReal()) {
-    while (xP < xPEnd) {
-      (*yP++) = expjLookup(phase)*( (xP++)->real() );
-      phase += freq;
-    }
-  }
-  else {
-    while (xP < xPEnd) {
-      (*yP++) = (*xP++)*expjLookup(phase);
-      phase += freq;
-      if (phase > 2 * M_PI)
-        phase -= 2 * M_PI;
-      else if (phase < -2 * M_PI)
-        phase += 2 * M_PI;
-    }
-  }
-
-
-  if (finalPhase) *finalPhase = phase;
-
-  return y;
-}
-
 signalVector* reverseConjugate(signalVector *b)
 {
     signalVector *tmp = new signalVector(b->size());
@@ -739,20 +692,6 @@ bool vectorSlicer(SoftVector *x)
   return true;
 }
 
-bool vectorSlicer(signalVector *x)
-{
-
-  signalVector::iterator xP = x->begin();
-  signalVector::iterator xPEnd = x->end();
-  while (xP < xPEnd) {
-    *xP = (complex) (0.5*(xP->real()+1.0F));
-    if (xP->real() > 1.0) *xP = 1.0;
-    if (xP->real() < 0.0) *xP = 0.0;
-    xP++;
-  }
-  return true;
-}
-
 static signalVector *rotateBurst(const BitVector &wBurst,
                                  int guardPeriodLength, int sps)
 {
@@ -818,8 +757,8 @@ static signalVector *modulateBurstLaurent(const BitVector &bits)
   c1_burst->isReal(true);
   c1_itr = c1_burst->begin();
 
-  /* Padded differential start bits */
-  *c0_itr = 2.0 * (0x01 & 0x01) - 1.0;
+  /* Padded differential tail bits */
+  *c0_itr = 2.0 * (0x00 & 0x01) - 1.0;
   c0_itr += sps;
 
   /* Main burst bits */
@@ -828,8 +767,8 @@ static signalVector *modulateBurstLaurent(const BitVector &bits)
     c0_itr += sps;
   }
 
-  /* Padded differential end bits */
-  *c0_itr = 2.0 * (0x01 & 0x01) - 1.0;
+  /* Padded differential tail bits */
+  *c0_itr = 2.0 * (0x00 & 0x01) - 1.0;
 
   /* Generate C0 phase coefficients */
   GMSKRotate(*c0_burst, sps);
@@ -958,7 +897,7 @@ static signalVector *shapeEdgeBurst(const signalVector &symbols)
 
   /* Delay burst by 1 symbol */
   burst_itr = burst->begin() + sps;
-  for (size_t i = 0; i < nsyms - 1; i++) {
+  for (size_t i = 0; i < nsyms; i++) {
     float phase = i * 3.0f * M_PI / 8.0f;
     Complex<float> rot = Complex<float>(cos(phase), sin(phase));
 
@@ -976,7 +915,7 @@ static signalVector *shapeEdgeBurst(const signalVector &symbols)
 /*
  * Generate a random GSM normal burst.
  */
-signalVector *genRandNormalBurst(int tsc, int sps, int tn)
+signalVector *genRandNormalBurst(int tsc, int sps, int tn, PRBS &prbs)
 {
   if ((tsc < 0) || (tsc > 7) || (tn < 0) || (tn > 7))
     return NULL;
@@ -988,20 +927,26 @@ signalVector *genRandNormalBurst(int tsc, int sps, int tn)
   signalVector *burst;
 
   /* Tail bits */
-  for (; i < 4; i++)
+  for (; i < 3; i++)
     (*bits)[i] = 0;
 
   /* Random bits */
-  for (; i < 61; i++)
-    (*bits)[i] = rand() % 2;
+  for (; i < 60; i++)
+    (*bits)[i] = prbs.generateBit();
+
+  /* Stealing bit */
+  (*bits)[i++] = 0;
 
   /* Training sequence */
   for (int n = 0; i < 87; i++, n++)
     (*bits)[i] = gTrainingSequence[tsc][n];
 
+  /* Stealing bit */
+  (*bits)[i++] = 0;
+
   /* Random bits */
-  for (; i < 144; i++)
-    (*bits)[i] = rand() % 2;
+  for (; i < 145; i++)
+    (*bits)[i] = prbs.generateBit();
 
   /* Tail bits */
   for (; i < 148; i++)
@@ -1126,7 +1071,7 @@ signalVector *generateEdgeBurst(int tsc)
  * Modulate 8-PSK burst. When empty pulse shaping (rotation only)
  * is enabled, the output vector length will be bit sequence length
  * times the SPS value. When pulse shaping is enabled, the output
- * vector length is fixed at 625 samples (156.25 sybols at 4 SPS).
+ * vector length is fixed at 625 samples (156.25 symbols at 4 SPS).
  * Pulse shaped bit sequences that go beyond one burst are truncated.
  * Pulse shaping at anything but 4 SPS is not supported.
  */
@@ -1269,7 +1214,7 @@ void generateDelayFilters()
   }
 }
 
-signalVector *delayVector(signalVector *in, signalVector *out, float delay)
+signalVector *delayVector(const signalVector *in, signalVector *out, float delay)
 {
   int whole, index;
   float frac;
@@ -1680,6 +1625,17 @@ release:
   return status;
 }
 
+/*
+ * Peak-to-average computation +/- range from peak in symbols
+ */
+#define COMPUTE_PEAK_MIN     2
+#define COMPUTE_PEAK_MAX     5
+
+/*
+ * Minimum number of values needed to compute peak-to-average
+ */
+#define COMPUTE_PEAK_CNT     5
+
 static float computePeakRatio(signalVector *corr,
                               int sps, float toa, complex amp)
 {
@@ -1693,7 +1649,7 @@ static float computePeakRatio(signalVector *corr,
 
   peak = corr->begin() + (int) rint(toa);
 
-  for (int i = 2 * sps; i <= 5 * sps; i++) {
+  for (int i = COMPUTE_PEAK_MIN * sps; i <= COMPUTE_PEAK_MAX * sps; i++) {
     if (peak - i >= corr->begin()) {
       avg += (peak - i)->norm2();
       num++;
@@ -1704,7 +1660,7 @@ static float computePeakRatio(signalVector *corr,
     }
   }
 
-  if (num < 2)
+  if (num < COMPUTE_PEAK_CNT)
     return 0.0;
 
   rms = sqrtf(avg / (float) num) + 0.00001;
@@ -1712,22 +1668,18 @@ static float computePeakRatio(signalVector *corr,
   return (amp.abs()) / rms;
 }
 
-bool energyDetect(signalVector &rxBurst,
-		  unsigned windowLength,
-		  float detectThreshold,
-                  float *avgPwr)
+float energyDetect(const signalVector &rxBurst, unsigned windowLength)
 {
 
   signalVector::const_iterator windowItr = rxBurst.begin(); //+rxBurst.size()/2 - 5*windowLength/2;
   float energy = 0.0;
-  if (windowLength < 0) windowLength = 20;
+  if (windowLength == 0) return 0.0;
   if (windowLength > rxBurst.size()) windowLength = rxBurst.size();
   for (unsigned i = 0; i < windowLength; i++) {
     energy += windowItr->norm2();
     windowItr+=4;
   }
-  if (avgPwr) *avgPwr = energy/windowLength;
-  return (energy/windowLength > detectThreshold*detectThreshold);
+  return energy/windowLength;
 }
 
 /*
@@ -1738,12 +1690,13 @@ bool energyDetect(signalVector &rxBurst,
  * For higher oversampling values, we assume the energy detector is in place
  * and we run full interpolating peak detection.
  */
-static int detectBurst(signalVector &burst,
+static int detectBurst(const signalVector &burst,
                        signalVector &corr, CorrelationSequence *sync,
                        float thresh, int sps, complex *amp, float *toa,
                        int start, int len)
 {
-  signalVector *corr_in, *dec = NULL;
+  const signalVector *corr_in;
+  signalVector *dec = NULL;
 
   if (sps == 4) {
     dec = downsampleBurst(burst);
@@ -1781,17 +1734,13 @@ static int detectBurst(signalVector &burst,
   /* Normalize our channel gain */
   *amp = *amp / sync->gain;
 
-  /* Compenate for residual rotation with dual Laurent pulse */
-  if (sps == 4)
-    *amp = *amp * complex(0.0, 1.0);
-
   /* Compensate for residuate time lag */
   *toa = *toa - sync->toa;
 
   return 1;
 }
 
-static float maxAmplitude(signalVector &burst)
+static float maxAmplitude(const signalVector &burst)
 {
     float max = 0.0;
     for (size_t i = 0; i < burst.size(); i++) {
@@ -1812,13 +1761,13 @@ static float maxAmplitude(signalVector &burst)
  *   head: Search symbols before target
  *   tail: Search symbols after target
  */
-int detectGeneralBurst(signalVector &rxBurst,
-                       float thresh,
-                       int sps,
-                       complex &amp,
-                       float &toa,
-                       int target, int head, int tail,
-                       CorrelationSequence *sync)
+static int detectGeneralBurst(const signalVector &rxBurst,
+                              float thresh,
+                              int sps,
+                              complex &amp,
+                              float &toa,
+                              int target, int head, int tail,
+                              CorrelationSequence *sync)
 {
   int rc, start, len;
   bool clipping = false;
@@ -1865,24 +1814,24 @@ int detectGeneralBurst(signalVector &rxBurst,
  * Correlation window parameters:
  *   target: Tail bits + RACH length (reduced from 41 to a multiple of 4)
  *   head: Search 8 symbols before target
- *   tail: Search 4 symbols + maximum expected delay
+ *   tail: Search 8 symbols + maximum expected delay
  */
-int detectRACHBurst(signalVector &rxBurst,
-            float thresh,
+int detectRACHBurst(const signalVector &burst,
+            float threshold,
             int sps,
-            complex &amp,
+            complex &amplitude,
             float &toa,
-            unsigned maxTOA)
+            unsigned max_toa)
 {
   int rc, target, head, tail;
   CorrelationSequence *sync;
 
   target = 8 + 40;
   head = 8;
-  tail = 4 + maxTOA;
+  tail = 8 + max_toa;
   sync = gRACHSequence;
 
-  rc = detectGeneralBurst(rxBurst, thresh, sps, amp, toa,
+  rc = detectGeneralBurst(burst, threshold, sps, amplitude, toa,
                           target, head, tail, sync);
 
   return rc;
@@ -1893,56 +1842,94 @@ int detectRACHBurst(signalVector &rxBurst,
  *
  * Correlation window parameters:
  *   target: Tail + data + mid-midamble + 1/2 remaining midamblebits
- *   head: Search 4 symbols before target
- *   tail: Search 4 symbols + maximum expected delay
+ *   head: Search 6 symbols before target
+ *   tail: Search 6 symbols + maximum expected delay
  */
-int analyzeTrafficBurst(signalVector &rxBurst, unsigned tsc, float thresh,
-                        int sps, complex &amp, float &toa, unsigned max_toa)
+int analyzeTrafficBurst(const signalVector &burst, unsigned tsc, float threshold,
+                        int sps, complex &amplitude, float &toa, unsigned max_toa)
 {
   int rc, target, head, tail;
   CorrelationSequence *sync;
 
-  if ((tsc < 0) || (tsc > 7))
+  if (tsc > 7)
     return -SIGERR_UNSUPPORTED;
 
   target = 3 + 58 + 16 + 5;
-  head = 4;
-  tail = 4 + max_toa;
+  head = 3;
+  tail = 3 + max_toa;
   sync = gMidambles[tsc];
 
-  rc = detectGeneralBurst(rxBurst, thresh, sps, amp, toa,
+  rc = detectGeneralBurst(burst, threshold, sps, amplitude, toa,
                           target, head, tail, sync);
   return rc;
 }
 
-int detectEdgeBurst(signalVector &rxBurst, unsigned tsc, float thresh,
-                    int sps, complex &amp, float &toa, unsigned max_toa)
+int detectEdgeBurst(const signalVector &burst, unsigned tsc, float threshold,
+                    int sps, complex &amplitude, float &toa, unsigned max_toa)
 {
   int rc, target, head, tail;
   CorrelationSequence *sync;
 
-  if ((tsc < 0) || (tsc > 7))
+  if (tsc > 7)
     return -SIGERR_UNSUPPORTED;
 
   target = 3 + 58 + 16 + 5;
-  head = 5;
-  tail = 5 + max_toa;
+  head = 6;
+  tail = 6 + max_toa;
   sync = gEdgeMidambles[tsc];
 
-  rc = detectGeneralBurst(rxBurst, thresh, sps, amp, toa,
+  rc = detectGeneralBurst(burst, threshold, sps, amplitude, toa,
                           target, head, tail, sync);
   return rc;
 }
 
-signalVector *downsampleBurst(signalVector &burst)
+int detectAnyBurst(const signalVector &burst, unsigned tsc, float threshold,
+                   int sps, CorrType type, complex &amp, float &toa,
+                   unsigned max_toa)
 {
-  size_t ilen = DOWNSAMPLE_IN_LEN, olen = DOWNSAMPLE_OUT_LEN;
+  int rc = 0;
 
-  signalVector *out = new signalVector(olen);
-  memcpy(dnsampler_in->begin(), burst.begin(), ilen * 2 * sizeof(float));
+  switch (type) {
+  case EDGE:
+    rc = detectEdgeBurst(burst, tsc, threshold, sps,
+                         amp, toa, max_toa);
+    if (rc > 0)
+      break;
+    else
+      type = TSC;
+  case TSC:
+    rc = analyzeTrafficBurst(burst, tsc, threshold, sps,
+                             amp, toa, max_toa);
+    break;
+  case RACH:
+    rc = detectRACHBurst(burst, threshold, sps, amp, toa,
+                         max_toa);
+    break;
+  default:
+    LOG(ERR) << "Invalid correlation type";
+  }
 
-  dnsampler->rotate((float *) dnsampler_in->begin(), ilen,
-                    (float *) out->begin(), olen);
+  if (rc > 0)
+    return type;
+
+  return rc;
+}
+
+signalVector *downsampleBurst(const signalVector &burst)
+{
+  signalVector *in, *out;
+
+  in = new signalVector(DOWNSAMPLE_IN_LEN, dnsampler->len());
+  out = new signalVector(DOWNSAMPLE_OUT_LEN);
+  memcpy(in->begin(), burst.begin(), DOWNSAMPLE_IN_LEN * 2 * sizeof(float));
+
+  if (dnsampler->rotate((float *) in->begin(), DOWNSAMPLE_IN_LEN,
+                        (float *) out->begin(), DOWNSAMPLE_OUT_LEN) < 0) {
+    delete out;
+    out = NULL;
+  }
+
+  delete in;
   return out;
 };
 
@@ -2012,13 +1999,29 @@ static SoftVector *softSliceEdgeBurst(signalVector &burst)
   return bits;
 }
 
+/*
+ * Convert signalVector to SoftVector by taking real part of the signal.
+ */
+static SoftVector *signalToSoftVector(signalVector *dec)
+{
+  SoftVector *bits = new SoftVector(dec->size());
+
+  SoftVector::iterator bit_itr = bits->begin();
+  signalVector::iterator burst_itr = dec->begin();
+
+  for (; burst_itr < dec->end(); burst_itr++)
+    *bit_itr++ = burst_itr->real();
+
+  return bits;
+}
+
 /*
  * Shared portion of GMSK and EDGE demodulators consisting of timing
  * recovery and single tap channel correction. For 4 SPS (if activated),
  * the output is downsampled prior to the 1 SPS modulation specific
  * stages.
  */
-static signalVector *demodCommon(signalVector &burst, int sps,
+static signalVector *demodCommon(const signalVector &burst, int sps,
                                  complex chan, float toa)
 {
   signalVector *delay, *dec;
@@ -2026,8 +2029,8 @@ static signalVector *demodCommon(signalVector &burst, int sps,
   if ((sps != 1) && (sps != 4))
     return NULL;
 
-  scaleVector(burst, (complex) 1.0 / chan);
   delay = delayVector(&burst, NULL, -toa * (float) sps);
+  scaleVector(*delay, (complex) 1.0 / chan);
 
   if (sps == 1)
     return delay;
@@ -2043,8 +2046,8 @@ static signalVector *demodCommon(signalVector &burst, int sps,
  * 4 SPS (if activated) to minimize distortion through the fractional
  * delay filters. Symbol rotation and after always operates at 1 SPS.
  */
-SoftVector *demodulateBurst(signalVector &rxBurst, int sps,
-                            complex channel, float TOA)
+SoftVector *demodGmskBurst(const signalVector &rxBurst, int sps,
+                           complex channel, float TOA)
 {
   SoftVector *bits;
   signalVector *dec;
@@ -2055,16 +2058,8 @@ SoftVector *demodulateBurst(signalVector &rxBurst, int sps,
 
   /* Shift up by a quarter of a frequency */
   GMSKReverseRotate(*dec, 1);
-  vectorSlicer(dec);
-
-  bits = new SoftVector(dec->size());
-
-  SoftVector::iterator bit_itr = bits->begin();
-  signalVector::iterator burst_itr = dec->begin();
-
-  for (; burst_itr < dec->end(); burst_itr++)
-    *bit_itr++ = burst_itr->real();
-
+  /* Take real part of the signal */
+  bits = signalToSoftVector(dec);
   delete dec;
 
   return bits;
@@ -2080,7 +2075,7 @@ SoftVector *demodulateBurst(signalVector &rxBurst, int sps,
  * through the fractional delay filters at 1 SPS renders signal
  * nearly unrecoverable.
  */
-SoftVector *demodEdgeBurst(signalVector &burst, int sps,
+SoftVector *demodEdgeBurst(const signalVector &burst, int sps,
                            complex chan, float toa)
 {
   SoftVector *bits;
@@ -2096,7 +2091,6 @@ SoftVector *demodEdgeBurst(signalVector &burst, int sps,
 
   /* Soft slice and normalize */
   bits = softSliceEdgeBurst(*rot);
-  vectorSlicer(bits);
 
   delete dec;
   delete eq;
@@ -2105,6 +2099,15 @@ SoftVector *demodEdgeBurst(signalVector &burst, int sps,
   return bits;
 }
 
+SoftVector *demodAnyBurst(const signalVector &burst, int sps, complex amp,
+                          float toa, CorrType type)
+{
+  if (type == EDGE)
+    return demodEdgeBurst(burst, sps, amp, toa);
+  else
+    return demodGmskBurst(burst, sps, amp, toa);
+}
+
 bool sigProcLibSetup()
 {
   initTrigTables();
@@ -2128,12 +2131,32 @@ bool sigProcLibSetup()
     goto fail;
   }
 
-  dnsampler->enableHistory(false);
-  dnsampler_in = new signalVector(DOWNSAMPLE_IN_LEN, dnsampler->len());
-
   return true;
 
 fail:
   sigProcLibDestroy();
   return false;
 }
+
+std::string corrTypeToString(CorrType corr) {
+  switch (corr) {
+  case OFF:
+    return "OFF";
+  case TSC:
+    return "TSC";
+  case RACH:
+    return "RACH";
+  case EDGE:
+    return "EDGE";
+  case IDLE:
+    return "IDLE";
+  default:
+    return "unknown";
+  }
+}
+
+std::ostream& operator<<(std::ostream& os, CorrType corr)
+{
+  os << corrTypeToString(corr);
+  return os;
+}

Transceiver52M/sigProcLib.h

@@ -18,12 +18,13 @@
 #include "Vector.h"
 #include "Complex.h"
 #include "BitVector.h"
+#include "PRBS.h"
 #include "signalVector.h"
 
 /* Burst lengths */
-#define NORMAL_BURST_NBITS		148
-#define EDGE_BURST_NBITS		444
-#define EDGE_BURST_NSYMS		(EDGE_BURST_NBITS / 3)
+#define NORMAL_BURST_NBITS    148
+#define EDGE_BURST_NBITS      444
+#define EDGE_BURST_NSYMS      (EDGE_BURST_NBITS / 3)
 
 /** Convolution type indicator */
 enum ConvType {
@@ -33,7 +34,18 @@ enum ConvType {
   UNDEFINED,
 };
 
-enum signalError {
+/** Codes for burst types of received bursts*/
+enum CorrType{
+  OFF,         ///< timeslot is off
+  TSC,         ///< timeslot should contain a normal burst
+  RACH,        ///< timeslot should contain an access burst
+  EDGE,        ///< timeslot should contain an EDGE burst
+  IDLE         ///< timeslot is an idle (or dummy) burst
+};
+std::string corrTypeToString(CorrType corr);
+std::ostream& operator<<(std::ostream& os, CorrType corr);
+
+enum SignalError {
   SIGERR_NONE,
   SIGERR_BOUNDS,
   SIGERR_CLIP,
@@ -41,6 +53,15 @@ enum signalError {
   SIGERR_INTERNAL,
 };
 
+/*
+ * Burst detection threshold
+ *
+ * Decision threshold value for burst gating on peak-to-average value of
+ * correlated synchronization sequences. Lower values pass more bursts up
+ * to upper layers but will increase the false detection rate.
+ */
+#define BURST_THRESH    4.0
+
 /** Convert a linear number to a dB value */
 float dB(float x);
 
@@ -59,55 +80,55 @@ bool sigProcLibSetup();
 /** Destroy the signal processing library */
 void sigProcLibDestroy(void);
 
-/** 
- 	Convolve two vectors. 
-	@param a,b The vectors to be convolved.
-	@param c, A preallocated vector to hold the convolution result.
-	@param spanType The type/span of the convolution.
-	@return The convolution result or NULL on error.
+/**
+        Convolve two vectors.
+        @param a,b The vectors to be convolved.
+        @param c, A preallocated vector to hold the convolution result.
+        @param spanType The type/span of the convolution.
+        @return The convolution result or NULL on error.
 */
 signalVector *convolve(const signalVector *a, const signalVector *b,
                        signalVector *c, ConvType spanType,
                        size_t start = 0, size_t len = 0,
                        size_t step = 1, int offset = 0);
 
-/** 
+/**
         Frequency shift a vector.
-	@param y The frequency shifted vector.
-	@param x The vector to-be-shifted.
-	@param freq The digital frequency shift
-	@param startPhase The starting phase of the oscillator 
-	@param finalPhase The final phase of the oscillator
-	@return The frequency shifted vector.
+        @param y The frequency shifted vector.
+        @param x The vector to-be-shifted.
+        @param freq The digital frequency shift
+        @param startPhase The starting phase of the oscillator
+        @param finalPhase The final phase of the oscillator
+        @return The frequency shifted vector.
 */
 signalVector* frequencyShift(signalVector *y,
-			     signalVector *x,
-			     float freq = 0.0,
-			     float startPhase = 0.0,
-			     float *finalPhase=NULL);
+                             signalVector *x,
+                             float freq = 0.0,
+                             float startPhase = 0.0,
+                             float *finalPhase=NULL);
 
-/** 
-        Correlate two vectors. 
+/**
+        Correlate two vectors.
         @param a,b The vectors to be correlated.
         @param c, A preallocated vector to hold the correlation result.
         @param spanType The type/span of the correlation.
         @return The correlation result.
 */
 signalVector* correlate(signalVector *a,
-			signalVector *b,
-			signalVector *c,
-			ConvType spanType,
+                        signalVector *b,
+                        signalVector *c,
+                        ConvType spanType,
                         bool bReversedConjugated = false,
-			unsigned startIx = 0,
-			unsigned len = 0);
+                        unsigned startIx = 0,
+                        unsigned len = 0);
 
-/** Operate soft slicer on real-valued portion of vector */ 
-bool vectorSlicer(signalVector *x);
+/** Operate soft slicer on a soft-bit vector */
+bool vectorSlicer(SoftVector *x);
 
 /** GMSK modulate a GSM burst of bits */
 signalVector *modulateBurst(const BitVector &wBurst,
-			    int guardPeriodLength,
-			    int sps, bool emptyPulse = false);
+                            int guardPeriodLength,
+                            int sps, bool emptyPulse = false);
 
 /** 8-PSK modulate a burst of bits */
 signalVector *modulateEdgeBurst(const BitVector &bits,
@@ -120,7 +141,7 @@ signalVector *generateEdgeBurst(int tsc);
 signalVector *generateEmptyBurst(int sps, int tn);
 
 /** Generate a normal GSM burst with random payload - 4 or 1 SPS */
-signalVector *genRandNormalBurst(int tsc, int sps, int tn);
+signalVector *genRandNormalBurst(int tsc, int sps, int tn, PRBS &prbs);
 
 /** Generate an access GSM burst with random payload - 4 or 1 SPS */
 signalVector *genRandAccessBurst(int delay, int sps, int tn);
@@ -132,11 +153,11 @@ signalVector *generateDummyBurst(int sps, int tn);
 float sinc(float x);
 
 /** Delay a vector */
-signalVector *delayVector(signalVector *in, signalVector *out, float delay);
+signalVector *delayVector(const signalVector *in, signalVector *out, float delay);
 
 /** Add two vectors in-place */
 bool addVector(signalVector &x,
-	       signalVector &y);
+               signalVector &y);
 
 /** Multiply two vectors in-place*/
 bool multVector(signalVector &x,
@@ -148,24 +169,24 @@ signalVector *gaussianNoise(int length,
                             complex mean = complex(0.0));
 
 /**
-	Given a non-integer index, interpolate a sample.
-	@param inSig The signal from which to interpolate.
-	@param ix The index.
-	@return The interpolated signal value.
+        Given a non-integer index, interpolate a sample.
+        @param inSig The signal from which to interpolate.
+        @param ix The index.
+        @return The interpolated signal value.
 */
 complex interpolatePoint(const signalVector &inSig,
-			 float ix);
+                         float ix);
 
 /**
-	Given a correlator output, locate the correlation peak.
-	@param rxBurst The correlator result.
-	@param peakIndex Pointer to value to receive interpolated peak index.
-	@param avgPower Power to value to receive mean power.
-	@return Peak value.
+        Given a correlator output, locate the correlation peak.
+        @param rxBurst The correlator result.
+        @param peakIndex Pointer to value to receive interpolated peak index.
+        @param avgPower Power to value to receive mean power.
+        @return Peak value.
 */
 complex peakDetect(const signalVector &rxBurst,
-		   float *peakIndex,
-		   float *avgPwr);
+                   float *peakIndex,
+                   float *avgPwr);
 
 /**
         Apply a scalar to a vector.
@@ -173,89 +194,109 @@ complex peakDetect(const signalVector &rxBurst,
         @param scale The scalar.
 */
 void scaleVector(signalVector &x,
-		 complex scale);
+                 complex scale);
 
 /**
-        Energy detector, checks to see if received burst energy is above a threshold.
-        @param rxBurst The received GSM burst of interest.
+        Rough energy estimator.
+        @param rxBurst A GSM burst.
         @param windowLength The number of burst samples used to compute burst energy
-        @param detectThreshold The detection threshold, a linear value.
-        @param avgPwr The average power of the received burst.
-        @return True if burst energy is above threshold.
+        @return The average power of the received burst.
 */
-bool energyDetect(signalVector &rxBurst,
-		  unsigned windowLength,
-                  float detectThreshold,
-                  float *avgPwr = NULL);
+float energyDetect(const signalVector &rxBurst,
+                   unsigned windowLength);
 
 /**
-        RACH correlator/detector.
-        @param rxBurst The received GSM burst of interest.
-        @param detectThreshold The threshold that the received burst's post-correlator SNR is compared against to determine validity.
+        RACH aka Access Burst correlator/detector.
+        @param burst The received GSM burst of interest.
+        @param threshold The threshold that the received burst's post-correlator SNR is compared against to determine validity.
         @param sps The number of samples per GSM symbol.
         @param amplitude The estimated amplitude of received RACH burst.
-        @param TOA The estimate time-of-arrival of received RACH burst.
-        @param maxTOA The maximum expected time-of-arrival
-        @return positive if threshold value is reached, negative on error, zero otherwise
+        @param toa The estimate time-of-arrival of received RACH burst.
+        @param max_toa The maximum expected time-of-arrival
+        @return 1 if threshold value is reached,
+                negative value (-SignalError) on error,
+                zero (SIGERR_NONE) if no burst is detected
 */
-int detectRACHBurst(signalVector &rxBurst,
-                    float detectThreshold,
+int detectRACHBurst(const signalVector &burst,
+                    float threshold,
                     int sps,
                     complex &amplitude,
-                    float &TOA,
-                    unsigned maxTOA);
+                    float &toa,
+                    unsigned max_toa);
 
 /**
-        Normal burst correlator, detector, channel estimator.
+        GMSK Normal Burst correlator/detector.
         @param rxBurst The received GSM burst of interest.
- 
-        @param detectThreshold The threshold that the received burst's post-correlator SNR is compared against to determine validity.
+        @param tsc Midamble type (0..7) also known as TSC
+        @param threshold The threshold that the received burst's post-correlator SNR is compared against to determine validity.
         @param sps The number of samples per GSM symbol.
         @param amplitude The estimated amplitude of received TSC burst.
-        @param TOA The estimate time-of-arrival of received TSC burst.
-        @param maxTOA The maximum expected time-of-arrival
-        @param requestChannel Set to true if channel estimation is desired.
-        @param channelResponse The estimated channel.
-        @param channelResponseOffset The time offset b/w the first sample of the channel response and the reported TOA.
-        @return positive if threshold value is reached, negative on error, zero otherwise
+        @param toa The estimate time-of-arrival of received TSC burst.
+        @param max_toa The maximum expected time-of-arrival
+        @return 1 if threshold value is reached,
+                negative value (-SignalError) on error,
+                zero (SIGERR_NONE) if no burst is detected
 */
-int analyzeTrafficBurst(signalVector &rxBurst,
-                        unsigned TSC,
-                        float detectThreshold,
+int analyzeTrafficBurst(const signalVector &burst,
+                        unsigned tsc,
+                        float threshold,
                         int sps,
                         complex &amplitude,
-                        float &TOA,
-                        unsigned maxTOA);
+                        float &toa,
+                        unsigned max_toa);
 
 /**
-        EDGE burst detector
+        EDGE/8-PSK Normal Burst correlator/detector
         @param burst The received GSM burst of interest
- 
-        @param detectThreshold The threshold that the received burst's post-correlator SNR is compared against to determine validity.
+        @param tsc Midamble type (0..7) also known as TSC
+        @param threshold The threshold that the received burst's post-correlator SNR is compared against to determine validity.
         @param sps The number of samples per GSM symbol.
         @param amplitude The estimated amplitude of received TSC burst.
-        @param TOA The estimate time-of-arrival of received TSC burst.
-        @param maxTOA The maximum expected time-of-arrival
-        @return positive if threshold value is reached, negative on error, zero otherwise
+        @param toa The estimate time-of-arrival of received TSC burst.
+        @param max_toa The maximum expected time-of-arrival
+        @return 1 if threshold value is reached,
+                negative value (-SignalError) on error,
+                zero (SIGERR_NONE) if no burst is detected
 */
-int detectEdgeBurst(signalVector &burst,
-                    unsigned TSC,
-                    float detectThreshold,
+int detectEdgeBurst(const signalVector &burst,
+                    unsigned tsc,
+                    float threshold,
                     int sps,
                     complex &amplitude,
-                    float &TOA,
-                    unsigned maxTOA);
+                    float &toa,
+                    unsigned max_toa);
 
 /**
-	Downsample 4 SPS to 1 SPS using a polyphase filterbank
+        8-PSK/GMSK/RACH burst detector
+        @param burst The received GSM burst of interest
+        @param tsc Midamble type (0..7) also known as TSC
+        @param threshold The threshold that the received burst's post-correlator SNR is compared against to determine validity.
+        @param sps The number of samples per GSM symbol.
+        @param amplitude The estimated amplitude of received TSC burst.
+        @param toa The estimate time-of-arrival of received TSC burst (in symbols).
+        @param max_toa The maximum expected time-of-arrival (in symbols).
+        @return positive value (CorrType) if threshold value is reached,
+                negative value (-SignalError) on error,
+                zero (SIGERR_NONE) if no burst is detected
+*/
+int detectAnyBurst(const signalVector &burst,
+                   unsigned tsc,
+                   float threshold,
+                   int sps,
+                   CorrType type,
+                   complex &amp,
+                   float &toa,
+                   unsigned max_toa);
+
+/**
+        Downsample 4 SPS to 1 SPS using a polyphase filterbank
         @param burst Input burst of at least 624 symbols
         @return Decimated signal vector of 156 symbols
 */
-
-signalVector *downsampleBurst(signalVector &burst);
+signalVector *downsampleBurst(const signalVector &burst);
 
 /**
-	Decimate a vector.
+        Decimate a vector.
         @param wVector The vector of interest.
         @param factor Decimation factor.
         @return The decimated signal vector.
@@ -263,26 +304,30 @@ signalVector *downsampleBurst(signalVector &burst);
 signalVector *decimateVector(signalVector &wVector, size_t factor);
 
 /**
-        Demodulates a received burst using a soft-slicer.
-	@param rxBurst The burst to be demodulated.
+        Demodulates a GMSK burst using a soft-slicer.
+        @param rxBurst The burst to be demodulated.
         @param gsmPulse The GSM pulse.
         @param sps The number of samples per GSM symbol.
         @param channel The amplitude estimate of the received burst.
         @param TOA The time-of-arrival of the received burst.
         @return The demodulated bit sequence.
 */
-SoftVector *demodulateBurst(signalVector &rxBurst, int sps,
-                            complex channel, float TOA);
+SoftVector *demodGmskBurst(const signalVector &rxBurst, int sps,
+                           complex channel, float TOA);
 
 /**
         Demodulate 8-PSK EDGE burst with soft symbol ooutput
-	@param rxBurst The burst to be demodulated.
+        @param rxBurst The burst to be demodulated.
         @param sps The number of samples per GSM symbol.
         @param channel The amplitude estimate of the received burst.
         @param TOA The time-of-arrival of the received burst.
         @return The demodulated bit sequence.
 */
-SoftVector *demodEdgeBurst(signalVector &rxBurst, int sps,
+SoftVector *demodEdgeBurst(const signalVector &rxBurst, int sps,
                            complex channel, float TOA);
 
+/** Demodulate burst basde on type and output soft bits */
+SoftVector *demodAnyBurst(const signalVector &burst, int sps,
+                          complex amp, float toa, CorrType type);
+
 #endif /* SIGPROCLIB_H */

Transceiver52M/signalVector.cpp

@@ -45,11 +45,25 @@ void signalVector::operator=(const signalVector& vector)
 	mStart = mData + vector.getStart();
 }
 
+signalVector signalVector::segment(size_t start, size_t span)
+{
+	return signalVector(mData, start, span);
+}
+
 size_t signalVector::getStart() const
 {
 	return mStart - mData;
 }
 
+size_t signalVector::updateHistory()
+{
+	size_t num = getStart();
+
+	memmove(mData, mStart + this->size() - num, num * sizeof(complex));
+
+	return num;
+}
+
 Symmetry signalVector::getSymmetry() const
 {
 	return symmetry;

Transceiver52M/signalVector.h

@@ -30,8 +30,12 @@ public:
 	/** Override base assignment operator to include start offsets */
 	void operator=(const signalVector& vector);
 
+	/** Return an alias to a segment of this signalVector. */
+	signalVector segment(size_t start, size_t span);
+
 	/** Return head room */
 	size_t getStart() const;
+	size_t updateHistory();
 
 	Symmetry getSymmetry() const;
 	void setSymmetry(Symmetry symmetry);

Transceiver52M/x86/Makefile.am

@@ -1,10 +1,32 @@
 if !ARCH_ARM
-AM_CFLAGS = -Wall -std=gnu99 -march=native -I${srcdir}/../common
+AM_CFLAGS = -Wall -std=gnu99 -I${srcdir}/../common
 
 noinst_LTLIBRARIES = libarch.la
+noinst_LTLIBRARIES += libarch_sse_3.la
+noinst_LTLIBRARIES += libarch_sse_4_1.la
+
+libarch_la_LIBADD =
+
+# SSE 3 specific code
+if HAVE_SSE3
+libarch_sse_3_la_SOURCES = \
+	convert_sse_3.c \
+	convolve_sse_3.c
+libarch_sse_3_la_CFLAGS = $(AM_CFLAGS) -msse3
+libarch_la_LIBADD += libarch_sse_3.la
+endif
+
+# SSE 4.1 specific code
+if HAVE_SSE4_1
+libarch_sse_4_1_la_SOURCES = \
+	convert_sse_4_1.c
+libarch_sse_4_1_la_CFLAGS = $(AM_CFLAGS) -msse4.1
+libarch_la_LIBADD += libarch_sse_4_1.la
+endif
 
 libarch_la_SOURCES = \
 	../common/convolve_base.c \
+	../common/convert_base.c \
 	convert.c \
 	convolve.c
 endif

Transceiver52M/x86/convert.c

@@ -20,182 +20,62 @@
 #include <malloc.h>
 #include <string.h>
 #include "convert.h"
+#include "convert_sse_3.h"
+#include "convert_sse_4_1.h"
 
 #ifdef HAVE_CONFIG_H
 #include "config.h"
 #endif
 
-#ifdef HAVE_SSE3
-#include <xmmintrin.h>
-#include <emmintrin.h>
+/* Architecture dependant function pointers */
+struct convert_cpu_context {
+	void (*convert_si16_ps_16n) (float *, const short *, int);
+	void (*convert_si16_ps) (float *, const short *, int);
+	void (*convert_scale_ps_si16_16n)(short *, const float *, float, int);
+	void (*convert_scale_ps_si16_8n)(short *, const float *, float, int);
+	void (*convert_scale_ps_si16)(short *, const float *, float, int);
+};
+
+static struct convert_cpu_context c;
+
+void convert_init(void)
+{
+	c.convert_scale_ps_si16_16n = base_convert_float_short;
+	c.convert_scale_ps_si16_8n = base_convert_float_short;
+	c.convert_scale_ps_si16 = base_convert_float_short;
+	c.convert_si16_ps_16n = base_convert_short_float;
+	c.convert_si16_ps = base_convert_short_float;
 
 #ifdef HAVE_SSE4_1
-#include <smmintrin.h>
-
-/* 16*N 16-bit signed integer converted to single precision floats */
-static void _sse_convert_si16_ps_16n(float *restrict out,
-				     const short *restrict in,
-				     int len)
-{
-	__m128i m0, m1, m2, m3, m4, m5;
-	__m128 m6, m7, m8, m9;
-
-	for (int i = 0; i < len / 16; i++) {
-		/* Load (unaligned) packed floats */
-		m0 = _mm_loadu_si128((__m128i *) &in[16 * i + 0]);
-		m1 = _mm_loadu_si128((__m128i *) &in[16 * i + 8]);
-
-		/* Unpack */
-		m2 = _mm_cvtepi16_epi32(m0);
-		m4 = _mm_cvtepi16_epi32(m1);
-		m0 = _mm_shuffle_epi32(m0, _MM_SHUFFLE(1, 0, 3, 2));
-		m1 = _mm_shuffle_epi32(m1, _MM_SHUFFLE(1, 0, 3, 2));
-		m3 = _mm_cvtepi16_epi32(m0);
-		m5 = _mm_cvtepi16_epi32(m1);
-
-		/* Convert */
-		m6 = _mm_cvtepi32_ps(m2);
-		m7 = _mm_cvtepi32_ps(m3);
-		m8 = _mm_cvtepi32_ps(m4);
-		m9 = _mm_cvtepi32_ps(m5);
-
-		/* Store */
-		_mm_storeu_ps(&out[16 * i + 0], m6);
-		_mm_storeu_ps(&out[16 * i + 4], m7);
-		_mm_storeu_ps(&out[16 * i + 8], m8);
-		_mm_storeu_ps(&out[16 * i + 12], m9);
+	if (__builtin_cpu_supports("sse4.1")) {
+		c.convert_si16_ps_16n = &_sse_convert_si16_ps_16n;
+		c.convert_si16_ps = &_sse_convert_si16_ps;
 	}
-}
-
-/* 16*N 16-bit signed integer conversion with remainder */
-static void _sse_convert_si16_ps(float *restrict out,
-				 const short *restrict in,
-				 int len)
-{
-	int start = len / 16 * 16;
-
-	_sse_convert_si16_ps_16n(out, in, len);
-
-	for (int i = 0; i < len % 16; i++)
-		out[start + i] = in[start + i];
-}
-#endif /* HAVE_SSE4_1 */
-
-/* 8*N single precision floats scaled and converted to 16-bit signed integer */
-static void _sse_convert_scale_ps_si16_8n(short *restrict out,
-					  const float *restrict in,
-					  float scale, int len)
-{
-	__m128 m0, m1, m2;
-	__m128i m4, m5;
-
-	for (int i = 0; i < len / 8; i++) {
-		/* Load (unaligned) packed floats */
-		m0 = _mm_loadu_ps(&in[8 * i + 0]);
-		m1 = _mm_loadu_ps(&in[8 * i + 4]);
-		m2 = _mm_load1_ps(&scale);
-
-		/* Scale */
-		m0 = _mm_mul_ps(m0, m2);
-		m1 = _mm_mul_ps(m1, m2);
-
-		/* Convert */
-		m4 = _mm_cvtps_epi32(m0);
-		m5 = _mm_cvtps_epi32(m1);
-
-		/* Pack and store */
-		m5 = _mm_packs_epi32(m4, m5);
-		_mm_storeu_si128((__m128i *) &out[8 * i], m5);
-	}
-}
-
-/* 8*N single precision floats scaled and converted with remainder */
-static void _sse_convert_scale_ps_si16(short *restrict out,
-				       const float *restrict in,
-				       float scale, int len)
-{
-	int start = len / 8 * 8;
-
-	_sse_convert_scale_ps_si16_8n(out, in, scale, len);
-
-	for (int i = 0; i < len % 8; i++)
-		out[start + i] = in[start + i] * scale;
-}
-
-/* 16*N single precision floats scaled and converted to 16-bit signed integer */
-static void _sse_convert_scale_ps_si16_16n(short *restrict out,
-					   const float *restrict in,
-					   float scale, int len)
-{
-	__m128 m0, m1, m2, m3, m4;
-	__m128i m5, m6, m7, m8;
-
-	for (int i = 0; i < len / 16; i++) {
-		/* Load (unaligned) packed floats */
-		m0 = _mm_loadu_ps(&in[16 * i + 0]);
-		m1 = _mm_loadu_ps(&in[16 * i + 4]);
-		m2 = _mm_loadu_ps(&in[16 * i + 8]);
-		m3 = _mm_loadu_ps(&in[16 * i + 12]);
-		m4 = _mm_load1_ps(&scale);
-
-		/* Scale */
-		m0 = _mm_mul_ps(m0, m4);
-		m1 = _mm_mul_ps(m1, m4);
-		m2 = _mm_mul_ps(m2, m4);
-		m3 = _mm_mul_ps(m3, m4);
-
-		/* Convert */
-		m5 = _mm_cvtps_epi32(m0);
-		m6 = _mm_cvtps_epi32(m1);
-		m7 = _mm_cvtps_epi32(m2);
-		m8 = _mm_cvtps_epi32(m3);
-
-		/* Pack and store */
-		m5 = _mm_packs_epi32(m5, m6);
-		m7 = _mm_packs_epi32(m7, m8);
-		_mm_storeu_si128((__m128i *) &out[16 * i + 0], m5);
-		_mm_storeu_si128((__m128i *) &out[16 * i + 8], m7);
-	}
-}
-#else /* HAVE_SSE3 */
-static void convert_scale_ps_si16(short *out, const float *in,
-				  float scale, int len)
-{
-	for (int i = 0; i < len; i++)
-		out[i] = in[i] * scale;
-}
 #endif
 
-#ifndef HAVE_SSE4_1
-static void convert_si16_ps(float *out, const short *in, int len)
-{
-	for (int i = 0; i < len; i++)
-		out[i] = in[i];
-}
+#ifdef HAVE_SSE3
+	if (__builtin_cpu_supports("sse3")) {
+		c.convert_scale_ps_si16_16n = _sse_convert_scale_ps_si16_16n;
+		c.convert_scale_ps_si16_8n = _sse_convert_scale_ps_si16_8n;
+		c.convert_scale_ps_si16 = _sse_convert_scale_ps_si16;
+	}
 #endif
+}
 
 void convert_float_short(short *out, const float *in, float scale, int len)
 {
-#ifdef HAVE_SSE3
 	if (!(len % 16))
-		_sse_convert_scale_ps_si16_16n(out, in, scale, len);
+		c.convert_scale_ps_si16_16n(out, in, scale, len);
 	else if (!(len % 8))
-		_sse_convert_scale_ps_si16_8n(out, in, scale, len);
+		c.convert_scale_ps_si16_8n(out, in, scale, len);
 	else
-		_sse_convert_scale_ps_si16(out, in, scale, len);
-#else
-	convert_scale_ps_si16(out, in, scale, len);
-#endif
+		c.convert_scale_ps_si16(out, in, scale, len);
 }
 
 void convert_short_float(float *out, const short *in, int len)
 {
-#ifdef HAVE_SSE4_1
 	if (!(len % 16))
-		_sse_convert_si16_ps_16n(out, in, len);
+		c.convert_si16_ps_16n(out, in, len);
 	else
-		_sse_convert_si16_ps(out, in, len);
-#else
-	convert_si16_ps(out, in, len);
-#endif
+		c.convert_si16_ps(out, in, len);
 }

Transceiver52M/x86/convert_sse_3.c

@@ -0,0 +1,107 @@
+/*
+ * SSE type conversions
+ * Copyright (C) 2013 Thomas Tsou <tom@tsou.cc>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#include <malloc.h>
+#include <string.h>
+#include "convert_sse_3.h"
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#ifdef HAVE_SSE3
+#include <xmmintrin.h>
+#include <emmintrin.h>
+
+/* 8*N single precision floats scaled and converted to 16-bit signed integer */
+void _sse_convert_scale_ps_si16_8n(short *restrict out,
+				   const float *restrict in,
+				   float scale, int len)
+{
+	__m128 m0, m1, m2;
+	__m128i m4, m5;
+
+	for (int i = 0; i < len / 8; i++) {
+		/* Load (unaligned) packed floats */
+		m0 = _mm_loadu_ps(&in[8 * i + 0]);
+		m1 = _mm_loadu_ps(&in[8 * i + 4]);
+		m2 = _mm_load1_ps(&scale);
+
+		/* Scale */
+		m0 = _mm_mul_ps(m0, m2);
+		m1 = _mm_mul_ps(m1, m2);
+
+		/* Convert */
+		m4 = _mm_cvtps_epi32(m0);
+		m5 = _mm_cvtps_epi32(m1);
+
+		/* Pack and store */
+		m5 = _mm_packs_epi32(m4, m5);
+		_mm_storeu_si128((__m128i *) & out[8 * i], m5);
+	}
+}
+
+/* 8*N single precision floats scaled and converted with remainder */
+void _sse_convert_scale_ps_si16(short *restrict out,
+				const float *restrict in, float scale, int len)
+{
+	int start = len / 8 * 8;
+
+	_sse_convert_scale_ps_si16_8n(out, in, scale, len);
+
+	for (int i = 0; i < len % 8; i++)
+		out[start + i] = in[start + i] * scale;
+}
+
+/* 16*N single precision floats scaled and converted to 16-bit signed integer */
+void _sse_convert_scale_ps_si16_16n(short *restrict out,
+				    const float *restrict in,
+				    float scale, int len)
+{
+	__m128 m0, m1, m2, m3, m4;
+	__m128i m5, m6, m7, m8;
+
+	for (int i = 0; i < len / 16; i++) {
+		/* Load (unaligned) packed floats */
+		m0 = _mm_loadu_ps(&in[16 * i + 0]);
+		m1 = _mm_loadu_ps(&in[16 * i + 4]);
+		m2 = _mm_loadu_ps(&in[16 * i + 8]);
+		m3 = _mm_loadu_ps(&in[16 * i + 12]);
+		m4 = _mm_load1_ps(&scale);
+
+		/* Scale */
+		m0 = _mm_mul_ps(m0, m4);
+		m1 = _mm_mul_ps(m1, m4);
+		m2 = _mm_mul_ps(m2, m4);
+		m3 = _mm_mul_ps(m3, m4);
+
+		/* Convert */
+		m5 = _mm_cvtps_epi32(m0);
+		m6 = _mm_cvtps_epi32(m1);
+		m7 = _mm_cvtps_epi32(m2);
+		m8 = _mm_cvtps_epi32(m3);
+
+		/* Pack and store */
+		m5 = _mm_packs_epi32(m5, m6);
+		m7 = _mm_packs_epi32(m7, m8);
+		_mm_storeu_si128((__m128i *) & out[16 * i + 0], m5);
+		_mm_storeu_si128((__m128i *) & out[16 * i + 8], m7);
+	}
+}
+#endif

Transceiver52M/x86/convert_sse_3.h

@@ -0,0 +1,34 @@
+/*
+ * SSE type conversions
+ * Copyright (C) 2013 Thomas Tsou <tom@tsou.cc>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#pragma once
+
+/* 8*N single precision floats scaled and converted to 16-bit signed integer */
+void _sse_convert_scale_ps_si16_8n(short *restrict out,
+				   const float *restrict in,
+				   float scale, int len);
+
+/* 8*N single precision floats scaled and converted with remainder */
+void _sse_convert_scale_ps_si16(short *restrict out,
+				const float *restrict in, float scale, int len);
+
+/* 16*N single precision floats scaled and converted to 16-bit signed integer */
+void _sse_convert_scale_ps_si16_16n(short *restrict out,
+				    const float *restrict in,
+				    float scale, int len);

Transceiver52M/x86/convert_sse_4_1.c

@@ -0,0 +1,77 @@
+/*
+ * SSE type conversions
+ * Copyright (C) 2013 Thomas Tsou <tom@tsou.cc>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#include <malloc.h>
+#include <string.h>
+#include "convert_sse_4_1.h"
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#ifdef HAVE_SSE4_1
+#include <smmintrin.h>
+
+/* 16*N 16-bit signed integer converted to single precision floats */
+void _sse_convert_si16_ps_16n(float *restrict out,
+			      const short *restrict in, int len)
+{
+	__m128i m0, m1, m2, m3, m4, m5;
+	__m128 m6, m7, m8, m9;
+
+	for (int i = 0; i < len / 16; i++) {
+		/* Load (unaligned) packed floats */
+		m0 = _mm_loadu_si128((__m128i *) & in[16 * i + 0]);
+		m1 = _mm_loadu_si128((__m128i *) & in[16 * i + 8]);
+
+		/* Unpack */
+		m2 = _mm_cvtepi16_epi32(m0);
+		m4 = _mm_cvtepi16_epi32(m1);
+		m0 = _mm_shuffle_epi32(m0, _MM_SHUFFLE(1, 0, 3, 2));
+		m1 = _mm_shuffle_epi32(m1, _MM_SHUFFLE(1, 0, 3, 2));
+		m3 = _mm_cvtepi16_epi32(m0);
+		m5 = _mm_cvtepi16_epi32(m1);
+
+		/* Convert */
+		m6 = _mm_cvtepi32_ps(m2);
+		m7 = _mm_cvtepi32_ps(m3);
+		m8 = _mm_cvtepi32_ps(m4);
+		m9 = _mm_cvtepi32_ps(m5);
+
+		/* Store */
+		_mm_storeu_ps(&out[16 * i + 0], m6);
+		_mm_storeu_ps(&out[16 * i + 4], m7);
+		_mm_storeu_ps(&out[16 * i + 8], m8);
+		_mm_storeu_ps(&out[16 * i + 12], m9);
+	}
+}
+
+/* 16*N 16-bit signed integer conversion with remainder */
+void _sse_convert_si16_ps(float *restrict out,
+			  const short *restrict in, int len)
+{
+	int start = len / 16 * 16;
+
+	_sse_convert_si16_ps_16n(out, in, len);
+
+	for (int i = 0; i < len % 16; i++)
+		out[start + i] = in[start + i];
+}
+
+#endif

Transceiver52M/x86/convert_sse_4_1.h

@@ -0,0 +1,28 @@
+/*
+ * SSE type conversions
+ * Copyright (C) 2013 Thomas Tsou <tom@tsou.cc>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#pragma once
+
+/* 16*N 16-bit signed integer converted to single precision floats */
+void _sse_convert_si16_ps_16n(float *restrict out,
+			      const short *restrict in, int len);
+
+/* 16*N 16-bit signed integer conversion with remainder */
+void _sse_convert_si16_ps(float *restrict out,
+			  const short *restrict in, int len);

Transceiver52M/x86/convolve.c

@@ -21,11 +21,37 @@
 #include <string.h>
 #include <stdio.h>
 #include "convolve.h"
+#include "convolve_sse_3.h"
 
 #ifdef HAVE_CONFIG_H
 #include "config.h"
 #endif
 
+/* Architecture dependant function pointers */
+struct convolve_cpu_context {
+	void (*conv_cmplx_4n) (const float *, int, const float *, int, float *,
+			       int, int, int, int, int);
+	void (*conv_cmplx_8n) (const float *, int, const float *, int, float *,
+			       int, int, int, int, int);
+	void (*conv_cmplx) (const float *, int, const float *, int, float *,
+			    int, int, int, int, int);
+	void (*conv_real4) (const float *, int, const float *, int, float *,
+			    int, int, int, int, int);
+	void (*conv_real8) (const float *, int, const float *, int, float *,
+			    int, int, int, int, int);
+	void (*conv_real12) (const float *, int, const float *, int, float *,
+			     int, int, int, int, int);
+	void (*conv_real16) (const float *, int, const float *, int, float *,
+			     int, int, int, int, int);
+	void (*conv_real20) (const float *, int, const float *, int, float *,
+			     int, int, int, int, int);
+	void (*conv_real4n) (const float *, int, const float *, int, float *,
+			     int, int, int, int, int);
+	void (*conv_real) (const float *, int, const float *, int, float *, int,
+			   int, int, int, int);
+};
+static struct convolve_cpu_context c;
+
 /* Forward declarations from base implementation */
 int _base_convolve_real(const float *x, int x_len,
 			const float *h, int h_len,
@@ -42,536 +68,77 @@ int _base_convolve_complex(const float *x, int x_len,
 int bounds_check(int x_len, int h_len, int y_len,
 		 int start, int len, int step);
 
+/* API: Initalize convolve module */
+void convolve_init(void)
+{
+	c.conv_cmplx_4n = (void *)_base_convolve_complex;
+	c.conv_cmplx_8n = (void *)_base_convolve_complex;
+	c.conv_cmplx = (void *)_base_convolve_complex;
+	c.conv_real4 = (void *)_base_convolve_real;
+	c.conv_real8 = (void *)_base_convolve_real;
+	c.conv_real12 = (void *)_base_convolve_real;
+	c.conv_real16 = (void *)_base_convolve_real;
+	c.conv_real20 = (void *)_base_convolve_real;
+	c.conv_real4n = (void *)_base_convolve_real;
+	c.conv_real = (void *)_base_convolve_real;
+
 #ifdef HAVE_SSE3
-#include <xmmintrin.h>
-#include <pmmintrin.h>
-
-/* 4-tap SSE complex-real convolution */
-static void sse_conv_real4(const float *restrict x,
-			   const float *restrict h,
-			   float *restrict y,
-			   int len)
-{
-	__m128 m0, m1, m2, m3, m4, m5, m6, m7;
-
-	/* Load (aligned) filter taps */
-	m0 = _mm_load_ps(&h[0]);
-	m1 = _mm_load_ps(&h[4]);
-	m7 = _mm_shuffle_ps(m0, m1, _MM_SHUFFLE(0, 2, 0, 2));
-
-	for (int i = 0; i < len; i++) {
-		/* Load (unaligned) input data */
-		m0 = _mm_loadu_ps(&x[2 * i + 0]);
-		m1 = _mm_loadu_ps(&x[2 * i + 4]);
-		m2 = _mm_shuffle_ps(m0, m1, _MM_SHUFFLE(0, 2, 0, 2));
-		m3 = _mm_shuffle_ps(m0, m1, _MM_SHUFFLE(1, 3, 1, 3));
-
-		/* Quad multiply */
-		m4 = _mm_mul_ps(m2, m7);
-		m5 = _mm_mul_ps(m3, m7);
-
-		/* Sum and store */
-		m6 = _mm_hadd_ps(m4, m5);
-		m0 = _mm_hadd_ps(m6, m6);
-
-		_mm_store_ss(&y[2 * i + 0], m0);
-		m0 = _mm_shuffle_ps(m0, m0, _MM_SHUFFLE(0, 3, 2, 1));
-		_mm_store_ss(&y[2 * i + 1], m0);
+	if (__builtin_cpu_supports("sse3")) {
+		c.conv_cmplx_4n = sse_conv_cmplx_4n;
+		c.conv_cmplx_8n = sse_conv_cmplx_8n;
+		c.conv_real4 = sse_conv_real4;
+		c.conv_real8 = sse_conv_real8;
+		c.conv_real12 = sse_conv_real12;
+		c.conv_real16 = sse_conv_real16;
+		c.conv_real20 = sse_conv_real20;
+		c.conv_real4n = sse_conv_real4n;
 	}
-}
-
-/* 8-tap SSE complex-real convolution */
-static void sse_conv_real8(const float *restrict x,
-			   const float *restrict h,
-			   float *restrict y,
-			   int len)
-{
-	__m128 m0, m1, m2, m3, m4, m5, m6, m7, m8, m9;
-
-	/* Load (aligned) filter taps */
-	m0 = _mm_load_ps(&h[0]);
-	m1 = _mm_load_ps(&h[4]);
-	m2 = _mm_load_ps(&h[8]);
-	m3 = _mm_load_ps(&h[12]);
-
-	m4 = _mm_shuffle_ps(m0, m1, _MM_SHUFFLE(0, 2, 0, 2));
-	m5 = _mm_shuffle_ps(m2, m3, _MM_SHUFFLE(0, 2, 0, 2));
-
-	for (int i = 0; i < len; i++) {
-		/* Load (unaligned) input data */
-		m0 = _mm_loadu_ps(&x[2 * i + 0]);
-		m1 = _mm_loadu_ps(&x[2 * i + 4]);
-		m2 = _mm_loadu_ps(&x[2 * i + 8]);
-		m3 = _mm_loadu_ps(&x[2 * i + 12]);
-
-		m6 = _mm_shuffle_ps(m0, m1, _MM_SHUFFLE(0, 2, 0, 2));
-		m7 = _mm_shuffle_ps(m0, m1, _MM_SHUFFLE(1, 3, 1, 3));
-		m8 = _mm_shuffle_ps(m2, m3, _MM_SHUFFLE(0, 2, 0, 2));
-		m9 = _mm_shuffle_ps(m2, m3, _MM_SHUFFLE(1, 3, 1, 3));
-
-		/* Quad multiply */
-		m6 = _mm_mul_ps(m6, m4);
-		m7 = _mm_mul_ps(m7, m4);
-		m8 = _mm_mul_ps(m8, m5);
-		m9 = _mm_mul_ps(m9, m5);
-
-		/* Sum and store */
-		m6 = _mm_add_ps(m6, m8);
-		m7 = _mm_add_ps(m7, m9);
-		m6 = _mm_hadd_ps(m6, m7);
-		m6 = _mm_hadd_ps(m6, m6);
-
-		_mm_store_ss(&y[2 * i + 0], m6);
-		m6 = _mm_shuffle_ps(m6, m6, _MM_SHUFFLE(0, 3, 2, 1));
-		_mm_store_ss(&y[2 * i + 1], m6);
-	}
-}
-
-/* 12-tap SSE complex-real convolution */
-static void sse_conv_real12(const float *restrict x,
-			    const float *restrict h,
-			    float *restrict y,
-			    int len)
-{
-	__m128 m0, m1, m2, m3, m4, m5, m6, m7;
-	__m128 m8, m9, m10, m11, m12, m13, m14;
-
-	/* Load (aligned) filter taps */
-	m0 = _mm_load_ps(&h[0]);
-	m1 = _mm_load_ps(&h[4]);
-	m2 = _mm_load_ps(&h[8]);
-	m3 = _mm_load_ps(&h[12]);
-	m4 = _mm_load_ps(&h[16]);
-	m5 = _mm_load_ps(&h[20]);
-
-	m12 = _mm_shuffle_ps(m0, m1, _MM_SHUFFLE(0, 2, 0, 2));
-	m13 = _mm_shuffle_ps(m2, m3, _MM_SHUFFLE(0, 2, 0, 2));
-	m14 = _mm_shuffle_ps(m4, m5, _MM_SHUFFLE(0, 2, 0, 2));
-
-	for (int i = 0; i < len; i++) {
-		/* Load (unaligned) input data */
-		m0 = _mm_loadu_ps(&x[2 * i + 0]);
-		m1 = _mm_loadu_ps(&x[2 * i + 4]);
-		m2 = _mm_loadu_ps(&x[2 * i + 8]);
-		m3 = _mm_loadu_ps(&x[2 * i + 12]);
-
-		m4 = _mm_shuffle_ps(m0, m1, _MM_SHUFFLE(0, 2, 0, 2));
-		m5 = _mm_shuffle_ps(m0, m1, _MM_SHUFFLE(1, 3, 1, 3));
-		m6 = _mm_shuffle_ps(m2, m3, _MM_SHUFFLE(0, 2, 0, 2));
-		m7 = _mm_shuffle_ps(m2, m3, _MM_SHUFFLE(1, 3, 1, 3));
-
-		m0 = _mm_loadu_ps(&x[2 * i + 16]);
-		m1 = _mm_loadu_ps(&x[2 * i + 20]);
-
-		m8 = _mm_shuffle_ps(m0, m1, _MM_SHUFFLE(0, 2, 0, 2));
-		m9 = _mm_shuffle_ps(m0, m1, _MM_SHUFFLE(1, 3, 1, 3));
-
-		/* Quad multiply */
-		m0 = _mm_mul_ps(m4, m12);
-		m1 = _mm_mul_ps(m5, m12);
-		m2 = _mm_mul_ps(m6, m13);
-		m3 = _mm_mul_ps(m7, m13);
-		m4 = _mm_mul_ps(m8, m14);
-		m5 = _mm_mul_ps(m9, m14);
-
-		/* Sum and store */
-		m8  = _mm_add_ps(m0, m2);
-		m9  = _mm_add_ps(m1, m3);
-		m10 = _mm_add_ps(m8, m4);
-		m11 = _mm_add_ps(m9, m5);
-
-		m2 = _mm_hadd_ps(m10, m11);
-		m3 = _mm_hadd_ps(m2, m2);
-
-		_mm_store_ss(&y[2 * i + 0], m3);
-		m3 = _mm_shuffle_ps(m3, m3, _MM_SHUFFLE(0, 3, 2, 1));
-		_mm_store_ss(&y[2 * i + 1], m3);
-	}
-}
-
-/* 16-tap SSE complex-real convolution */
-static void sse_conv_real16(const float *restrict x,
-			    const float *restrict h,
-			    float *restrict y,
-			    int len)
-{
-	__m128 m0, m1, m2, m3, m4, m5, m6, m7;
-	__m128 m8, m9, m10, m11, m12, m13, m14, m15;
-
-	/* Load (aligned) filter taps */
-	m0 = _mm_load_ps(&h[0]);
-	m1 = _mm_load_ps(&h[4]);
-	m2 = _mm_load_ps(&h[8]);
-	m3 = _mm_load_ps(&h[12]);
-
-	m4 = _mm_load_ps(&h[16]);
-	m5 = _mm_load_ps(&h[20]);
-	m6 = _mm_load_ps(&h[24]);
-	m7 = _mm_load_ps(&h[28]);
-
-	m12 = _mm_shuffle_ps(m0, m1, _MM_SHUFFLE(0, 2, 0, 2));
-	m13 = _mm_shuffle_ps(m2, m3, _MM_SHUFFLE(0, 2, 0, 2));
-	m14 = _mm_shuffle_ps(m4, m5, _MM_SHUFFLE(0, 2, 0, 2));
-	m15 = _mm_shuffle_ps(m6, m7, _MM_SHUFFLE(0, 2, 0, 2));
-
-	for (int i = 0; i < len; i++) {
-		/* Load (unaligned) input data */
-		m0 = _mm_loadu_ps(&x[2 * i + 0]);
-		m1 = _mm_loadu_ps(&x[2 * i + 4]);
-		m2 = _mm_loadu_ps(&x[2 * i + 8]);
-		m3 = _mm_loadu_ps(&x[2 * i + 12]);
-
-		m4 = _mm_shuffle_ps(m0, m1, _MM_SHUFFLE(0, 2, 0, 2));
-		m5 = _mm_shuffle_ps(m0, m1, _MM_SHUFFLE(1, 3, 1, 3));
-		m6 = _mm_shuffle_ps(m2, m3, _MM_SHUFFLE(0, 2, 0, 2));
-		m7 = _mm_shuffle_ps(m2, m3, _MM_SHUFFLE(1, 3, 1, 3));
-
-		m0 = _mm_loadu_ps(&x[2 * i + 16]);
-		m1 = _mm_loadu_ps(&x[2 * i + 20]);
-		m2 = _mm_loadu_ps(&x[2 * i + 24]);
-		m3 = _mm_loadu_ps(&x[2 * i + 28]);
-
-		m8  = _mm_shuffle_ps(m0, m1, _MM_SHUFFLE(0, 2, 0, 2));
-		m9  = _mm_shuffle_ps(m0, m1, _MM_SHUFFLE(1, 3, 1, 3));
-		m10 = _mm_shuffle_ps(m2, m3, _MM_SHUFFLE(0, 2, 0, 2));
-		m11 = _mm_shuffle_ps(m2, m3, _MM_SHUFFLE(1, 3, 1, 3));
-
-		/* Quad multiply */
-		m0 = _mm_mul_ps(m4, m12);
-		m1 = _mm_mul_ps(m5, m12);
-		m2 = _mm_mul_ps(m6, m13);
-		m3 = _mm_mul_ps(m7, m13);
-
-		m4 = _mm_mul_ps(m8, m14);
-		m5 = _mm_mul_ps(m9, m14);
-		m6 = _mm_mul_ps(m10, m15);
-		m7 = _mm_mul_ps(m11, m15);
-
-		/* Sum and store */
-		m8  = _mm_add_ps(m0, m2);
-		m9  = _mm_add_ps(m1, m3);
-		m10 = _mm_add_ps(m4, m6);
-		m11 = _mm_add_ps(m5, m7);
-
-		m0 = _mm_add_ps(m8, m10);
-		m1 = _mm_add_ps(m9, m11);
-		m2 = _mm_hadd_ps(m0, m1);
-		m3 = _mm_hadd_ps(m2, m2);
-
-		_mm_store_ss(&y[2 * i + 0], m3);
-		m3 = _mm_shuffle_ps(m3, m3, _MM_SHUFFLE(0, 3, 2, 1));
-		_mm_store_ss(&y[2 * i + 1], m3);
-	}
-}
-
-/* 20-tap SSE complex-real convolution */
-static void sse_conv_real20(const float *restrict x,
-			    const float *restrict h,
-			    float *restrict y,
-			    int len)
-{
-	__m128 m0, m1, m2, m3, m4, m5, m6, m7;
-	__m128 m8, m9, m11, m12, m13, m14, m15;
-
-	/* Load (aligned) filter taps */
-	m0 = _mm_load_ps(&h[0]);
-	m1 = _mm_load_ps(&h[4]);
-	m2 = _mm_load_ps(&h[8]);
-	m3 = _mm_load_ps(&h[12]);
-	m4 = _mm_load_ps(&h[16]);
-	m5 = _mm_load_ps(&h[20]);
-	m6 = _mm_load_ps(&h[24]);
-	m7 = _mm_load_ps(&h[28]);
-	m8 = _mm_load_ps(&h[32]);
-	m9 = _mm_load_ps(&h[36]);
-
-	m11 = _mm_shuffle_ps(m0, m1, _MM_SHUFFLE(0, 2, 0, 2));
-	m12 = _mm_shuffle_ps(m2, m3, _MM_SHUFFLE(0, 2, 0, 2));
-	m13 = _mm_shuffle_ps(m4, m5, _MM_SHUFFLE(0, 2, 0, 2));
-	m14 = _mm_shuffle_ps(m6, m7, _MM_SHUFFLE(0, 2, 0, 2));
-	m15 = _mm_shuffle_ps(m8, m9, _MM_SHUFFLE(0, 2, 0, 2));
-
-	for (int i = 0; i < len; i++) {
-		/* Multiply-accumulate first 12 taps */
-		m0 = _mm_loadu_ps(&x[2 * i + 0]);
-		m1 = _mm_loadu_ps(&x[2 * i + 4]);
-		m2 = _mm_loadu_ps(&x[2 * i + 8]);
-		m3 = _mm_loadu_ps(&x[2 * i + 12]);
-		m4 = _mm_loadu_ps(&x[2 * i + 16]);
-		m5 = _mm_loadu_ps(&x[2 * i + 20]);
-
-		m6  = _mm_shuffle_ps(m0, m1, _MM_SHUFFLE(0, 2, 0, 2));
-		m7  = _mm_shuffle_ps(m0, m1, _MM_SHUFFLE(1, 3, 1, 3));
-		m8  = _mm_shuffle_ps(m2, m3, _MM_SHUFFLE(0, 2, 0, 2));
-		m9  = _mm_shuffle_ps(m2, m3, _MM_SHUFFLE(1, 3, 1, 3));
-		m0  = _mm_shuffle_ps(m4, m5, _MM_SHUFFLE(0, 2, 0, 2));
-		m1  = _mm_shuffle_ps(m4, m5, _MM_SHUFFLE(1, 3, 1, 3));
-
-		m2 = _mm_mul_ps(m6, m11);
-		m3 = _mm_mul_ps(m7, m11);
-		m4 = _mm_mul_ps(m8, m12);
-		m5 = _mm_mul_ps(m9, m12);
-		m6 = _mm_mul_ps(m0, m13);
-		m7 = _mm_mul_ps(m1, m13);
-
-		m0  = _mm_add_ps(m2, m4);
-		m1  = _mm_add_ps(m3, m5);
-		m8  = _mm_add_ps(m0, m6);
-		m9  = _mm_add_ps(m1, m7);
-
-		/* Multiply-accumulate last 8 taps */
-		m0 = _mm_loadu_ps(&x[2 * i + 24]);
-		m1 = _mm_loadu_ps(&x[2 * i + 28]);
-		m2 = _mm_loadu_ps(&x[2 * i + 32]);
-		m3 = _mm_loadu_ps(&x[2 * i + 36]);
-
-		m4 = _mm_shuffle_ps(m0, m1, _MM_SHUFFLE(0, 2, 0, 2));
-		m5 = _mm_shuffle_ps(m0, m1, _MM_SHUFFLE(1, 3, 1, 3));
-		m6 = _mm_shuffle_ps(m2, m3, _MM_SHUFFLE(0, 2, 0, 2));
-		m7 = _mm_shuffle_ps(m2, m3, _MM_SHUFFLE(1, 3, 1, 3));
-
-		m0 = _mm_mul_ps(m4, m14);
-		m1 = _mm_mul_ps(m5, m14);
-		m2 = _mm_mul_ps(m6, m15);
-		m3 = _mm_mul_ps(m7, m15);
-
-		m4  = _mm_add_ps(m0, m2);
-		m5  = _mm_add_ps(m1, m3);
-
-		/* Final sum and store */
-		m0 = _mm_add_ps(m8, m4);
-		m1 = _mm_add_ps(m9, m5);
-		m2 = _mm_hadd_ps(m0, m1);
-		m3 = _mm_hadd_ps(m2, m2);
-
-		_mm_store_ss(&y[2 * i + 0], m3);
-		m3 = _mm_shuffle_ps(m3, m3, _MM_SHUFFLE(0, 3, 2, 1));
-		_mm_store_ss(&y[2 * i + 1], m3);
-	}
-}
-
-/* 4*N-tap SSE complex-real convolution */
-static void sse_conv_real4n(const float *x,
-			    const float *h,
-			    float *y,
-			    int h_len, int len)
-{
-	__m128 m0, m1, m2, m4, m5, m6, m7;
-
-	for (int i = 0; i < len; i++) {
-		/* Zero */
-		m6 = _mm_setzero_ps();
-		m7 = _mm_setzero_ps();
-
-		for (int n = 0; n < h_len / 4; n++) {
-			/* Load (aligned) filter taps */
-			m0 = _mm_load_ps(&h[8 * n + 0]);
-			m1 = _mm_load_ps(&h[8 * n + 4]);
-			m2 = _mm_shuffle_ps(m0, m1, _MM_SHUFFLE(0, 2, 0, 2));
-
-			/* Load (unaligned) input data */
-			m0 = _mm_loadu_ps(&x[2 * i + 8 * n + 0]);
-			m1 = _mm_loadu_ps(&x[2 * i + 8 * n + 4]);
-			m4 = _mm_shuffle_ps(m0, m1, _MM_SHUFFLE(0, 2, 0, 2));
-			m5 = _mm_shuffle_ps(m0, m1, _MM_SHUFFLE(1, 3, 1, 3));
-
-			/* Quad multiply */
-			m0 = _mm_mul_ps(m2, m4);
-			m1 = _mm_mul_ps(m2, m5);
-
-			/* Accumulate */
-			m6 = _mm_add_ps(m6, m0);
-			m7 = _mm_add_ps(m7, m1);
-		}
-
-		m0 = _mm_hadd_ps(m6, m7);
-		m0 = _mm_hadd_ps(m0, m0);
-
-		_mm_store_ss(&y[2 * i + 0], m0);
-		m0 = _mm_shuffle_ps(m0, m0, _MM_SHUFFLE(0, 3, 2, 1));
-		_mm_store_ss(&y[2 * i + 1], m0);
-	}
-}
-
-/* 4*N-tap SSE complex-complex convolution */
-static void sse_conv_cmplx_4n(const float *x,
-			      const float *h,
-			      float *y,
-			      int h_len, int len)
-{
-	__m128 m0, m1, m2, m3, m4, m5, m6, m7;
-
-	for (int i = 0; i < len; i++) {
-		/* Zero */
-		m6 = _mm_setzero_ps();
-		m7 = _mm_setzero_ps();
-
-		for (int n = 0; n < h_len / 4; n++) {
-			/* Load (aligned) filter taps */
-			m0 = _mm_load_ps(&h[8 * n + 0]);
-			m1 = _mm_load_ps(&h[8 * n + 4]);
-			m2 = _mm_shuffle_ps(m0, m1, _MM_SHUFFLE(0, 2, 0, 2));
-			m3 = _mm_shuffle_ps(m0, m1, _MM_SHUFFLE(1, 3, 1, 3));
-
-			/* Load (unaligned) input data */
-			m0 = _mm_loadu_ps(&x[2 * i + 8 * n + 0]);
-			m1 = _mm_loadu_ps(&x[2 * i + 8 * n + 4]);
-			m4 = _mm_shuffle_ps(m0, m1, _MM_SHUFFLE(0, 2, 0, 2));
-			m5 = _mm_shuffle_ps(m0, m1, _MM_SHUFFLE(1, 3, 1, 3));
-
-			/* Quad multiply */
-			m0 = _mm_mul_ps(m2, m4);
-			m1 = _mm_mul_ps(m3, m5);
-
-			m2 = _mm_mul_ps(m2, m5);
-			m3 = _mm_mul_ps(m3, m4);
-
-			/* Sum */
-			m0 = _mm_sub_ps(m0, m1);
-			m2 = _mm_add_ps(m2, m3);
-
-			/* Accumulate */
-			m6 = _mm_add_ps(m6, m0);
-			m7 = _mm_add_ps(m7, m2);
-		}
-
-		m0 = _mm_hadd_ps(m6, m7);
-		m0 = _mm_hadd_ps(m0, m0);
-
-		_mm_store_ss(&y[2 * i + 0], m0);
-		m0 = _mm_shuffle_ps(m0, m0, _MM_SHUFFLE(0, 3, 2, 1));
-		_mm_store_ss(&y[2 * i + 1], m0);
-	}
-}
-
-/* 8*N-tap SSE complex-complex convolution */
-static void sse_conv_cmplx_8n(const float *x,
-			      const float *h,
-			      float *y,
-			      int h_len, int len)
-{
-	__m128 m0, m1, m2, m3, m4, m5, m6, m7;
-	__m128 m8, m9, m10, m11, m12, m13, m14, m15;
-
-	for (int i = 0; i < len; i++) {
-		/* Zero */
-		m12 = _mm_setzero_ps();
-		m13 = _mm_setzero_ps();
-		m14 = _mm_setzero_ps();
-		m15 = _mm_setzero_ps();
-
-		for (int n = 0; n < h_len / 8; n++) {
-			/* Load (aligned) filter taps */
-			m0 = _mm_load_ps(&h[16 * n + 0]);
-			m1 = _mm_load_ps(&h[16 * n + 4]);
-			m2 = _mm_load_ps(&h[16 * n + 8]);
-			m3 = _mm_load_ps(&h[16 * n + 12]);
-
-			m4 = _mm_shuffle_ps(m0, m1, _MM_SHUFFLE(0, 2, 0, 2));
-			m5 = _mm_shuffle_ps(m0, m1, _MM_SHUFFLE(1, 3, 1, 3));
-			m6 = _mm_shuffle_ps(m2, m3, _MM_SHUFFLE(0, 2, 0, 2));
-			m7 = _mm_shuffle_ps(m2, m3, _MM_SHUFFLE(1, 3, 1, 3));
-
-			/* Load (unaligned) input data */
-			m0 = _mm_loadu_ps(&x[2 * i + 16 * n + 0]);
-			m1 = _mm_loadu_ps(&x[2 * i + 16 * n + 4]);
-			m2 = _mm_loadu_ps(&x[2 * i + 16 * n + 8]);
-			m3 = _mm_loadu_ps(&x[2 * i + 16 * n + 12]);
-
-			m8  = _mm_shuffle_ps(m0, m1, _MM_SHUFFLE(0, 2, 0, 2));
-			m9  = _mm_shuffle_ps(m0, m1, _MM_SHUFFLE(1, 3, 1, 3));
-			m10 = _mm_shuffle_ps(m2, m3, _MM_SHUFFLE(0, 2, 0, 2));
-			m11 = _mm_shuffle_ps(m2, m3, _MM_SHUFFLE(1, 3, 1, 3));
-
-			/* Quad multiply */
-			m0 = _mm_mul_ps(m4, m8);
-			m1 = _mm_mul_ps(m5, m9);
-			m2 = _mm_mul_ps(m6, m10);
-			m3 = _mm_mul_ps(m7, m11);
-
-			m4 = _mm_mul_ps(m4, m9);
-			m5 = _mm_mul_ps(m5, m8);
-			m6 = _mm_mul_ps(m6, m11);
-			m7 = _mm_mul_ps(m7, m10);
-
-			/* Sum */
-			m0 = _mm_sub_ps(m0, m1);
-			m2 = _mm_sub_ps(m2, m3);
-			m4 = _mm_add_ps(m4, m5);
-			m6 = _mm_add_ps(m6, m7);
-
-			/* Accumulate */
-			m12 = _mm_add_ps(m12, m0);
-			m13 = _mm_add_ps(m13, m2);
-			m14 = _mm_add_ps(m14, m4);
-			m15 = _mm_add_ps(m15, m6);
-		}
-
-		m0 = _mm_add_ps(m12, m13);
-		m1 = _mm_add_ps(m14, m15);
-		m2 = _mm_hadd_ps(m0, m1);
-		m2 = _mm_hadd_ps(m2, m2);
-
-		_mm_store_ss(&y[2 * i + 0], m2);
-		m2 = _mm_shuffle_ps(m2, m2, _MM_SHUFFLE(0, 3, 2, 1));
-		_mm_store_ss(&y[2 * i + 1], m2);
-	}
-}
 #endif
+}
 
 /* API: Aligned complex-real */
 int convolve_real(const float *x, int x_len,
 		  const float *h, int h_len,
-		  float *y, int y_len,
-		  int start, int len,
-		  int step, int offset)
+		  float *y, int y_len, int start, int len, int step, int offset)
 {
-	void (*conv_func)(const float *, const float *,
-			  float *, int) = NULL;
-	void (*conv_func_n)(const float *, const float *,
-			    float *, int, int) = NULL;
-
 	if (bounds_check(x_len, h_len, y_len, start, len, step) < 0)
 		return -1;
 
 	memset(y, 0, len * 2 * sizeof(float));
 
-#ifdef HAVE_SSE3
 	if (step <= 4) {
 		switch (h_len) {
 		case 4:
-			conv_func = sse_conv_real4;
+			c.conv_real4(x, x_len, h, h_len, y, y_len, start, len,
+				     step, offset);
 			break;
 		case 8:
-			conv_func = sse_conv_real8;
+			c.conv_real8(x, x_len, h, h_len, y, y_len, start, len,
+				     step, offset);
 			break;
 		case 12:
-			conv_func = sse_conv_real12;
+			c.conv_real12(x, x_len, h, h_len, y, y_len, start, len,
+				      step, offset);
 			break;
 		case 16:
-			conv_func = sse_conv_real16;
+			c.conv_real16(x, x_len, h, h_len, y, y_len, start, len,
+				      step, offset);
 			break;
 		case 20:
-			conv_func = sse_conv_real20;
+			c.conv_real20(x, x_len, h, h_len, y, y_len, start, len,
+				      step, offset);
 			break;
 		default:
 			if (!(h_len % 4))
-				conv_func_n = sse_conv_real4n;
+				c.conv_real4n(x, x_len, h, h_len, y, y_len,
+					      start, len, step, offset);
+			else
+				c.conv_real(x, x_len, h, h_len, y, y_len, start,
+					    len, step, offset);
 		}
-	}
-#endif
-	if (conv_func) {
-		conv_func(&x[2 * (-(h_len - 1) + start)],
-			  h, y, len);
-	} else if (conv_func_n) {
-		conv_func_n(&x[2 * (-(h_len - 1) + start)],
-			    h, y, h_len, len);
-	} else {
-		_base_convolve_real(x, x_len,
-				    h, h_len,
-				    y, y_len,
-				    start, len, step, offset);
-	}
+	} else
+		c.conv_real(x, x_len, h, h_len, y, y_len, start, len, step,
+			    offset);
 
 	return len;
 }
@@ -580,34 +147,26 @@ int convolve_real(const float *x, int x_len,
 int convolve_complex(const float *x, int x_len,
 		     const float *h, int h_len,
 		     float *y, int y_len,
-		     int start, int len,
-		     int step, int offset)
+		     int start, int len, int step, int offset)
 {
-	void (*conv_func)(const float *, const float *,
-			  float *, int, int) = NULL;
-
 	if (bounds_check(x_len, h_len, y_len, start, len, step) < 0)
 		return -1;
 
 	memset(y, 0, len * 2 * sizeof(float));
 
-#ifdef HAVE_SSE3
 	if (step <= 4) {
 		if (!(h_len % 8))
-			conv_func = sse_conv_cmplx_8n;
+			c.conv_cmplx_8n(x, x_len, h, h_len, y, y_len, start,
+					len, step, offset);
 		else if (!(h_len % 4))
-			conv_func = sse_conv_cmplx_4n;
-	}
-#endif
-	if (conv_func) {
-		conv_func(&x[2 * (-(h_len - 1) + start)],
-			  h, y, h_len, len);
-	} else {
-		_base_convolve_complex(x, x_len,
-				       h, h_len,
-				       y, y_len,
-				       start, len, step, offset);
-	}
+			c.conv_cmplx_4n(x, x_len, h, h_len, y, y_len, start,
+					len, step, offset);
+		else
+			c.conv_cmplx(x, x_len, h, h_len, y, y_len, start, len,
+				     step, offset);
+	} else
+		c.conv_cmplx(x, x_len, h, h_len, y, y_len, start, len, step,
+			     offset);
 
 	return len;
 }

Transceiver52M/x86/convolve_sse_3.c

@@ -0,0 +1,542 @@
+/*
+ * SSE Convolution
+ * Copyright (C) 2012, 2013 Thomas Tsou <tom@tsou.cc>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#include <malloc.h>
+#include <string.h>
+#include <stdio.h>
+#include "convolve_sse_3.h"
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#ifdef HAVE_SSE3
+#include <xmmintrin.h>
+#include <pmmintrin.h>
+
+/* 4-tap SSE complex-real convolution */
+void sse_conv_real4(const float *x, int x_len,
+		    const float *h, int h_len,
+		    float *y, int y_len,
+		    int start, int len, int step, int offset)
+{
+	/* NOTE: The parameter list of this function has to match the parameter
+	 * list of _base_convolve_real() in convolve_base.c. This specific
+	 * implementation, ignores some of the parameters of
+	 * _base_convolve_complex(), which are: x_len, y_len, offset, step */
+
+	__m128 m0, m1, m2, m3, m4, m5, m6, m7;
+
+	const float *_x = &x[2 * (-(h_len - 1) + start)];
+
+	/* Load (aligned) filter taps */
+	m0 = _mm_load_ps(&h[0]);
+	m1 = _mm_load_ps(&h[4]);
+	m7 = _mm_shuffle_ps(m0, m1, _MM_SHUFFLE(0, 2, 0, 2));
+
+	for (int i = 0; i < len; i++) {
+		/* Load (unaligned) input data */
+		m0 = _mm_loadu_ps(&_x[2 * i + 0]);
+		m1 = _mm_loadu_ps(&_x[2 * i + 4]);
+		m2 = _mm_shuffle_ps(m0, m1, _MM_SHUFFLE(0, 2, 0, 2));
+		m3 = _mm_shuffle_ps(m0, m1, _MM_SHUFFLE(1, 3, 1, 3));
+
+		/* Quad multiply */
+		m4 = _mm_mul_ps(m2, m7);
+		m5 = _mm_mul_ps(m3, m7);
+
+		/* Sum and store */
+		m6 = _mm_hadd_ps(m4, m5);
+		m0 = _mm_hadd_ps(m6, m6);
+
+		_mm_store_ss(&y[2 * i + 0], m0);
+		m0 = _mm_shuffle_ps(m0, m0, _MM_SHUFFLE(0, 3, 2, 1));
+		_mm_store_ss(&y[2 * i + 1], m0);
+	}
+}
+
+/* 8-tap SSE complex-real convolution */
+void sse_conv_real8(const float *x, int x_len,
+		    const float *h, int h_len,
+		    float *y, int y_len,
+		    int start, int len, int step, int offset)
+{
+	/* See NOTE in sse_conv_real4() */
+
+	__m128 m0, m1, m2, m3, m4, m5, m6, m7, m8, m9;
+
+	const float *_x = &x[2 * (-(h_len - 1) + start)];
+
+	/* Load (aligned) filter taps */
+	m0 = _mm_load_ps(&h[0]);
+	m1 = _mm_load_ps(&h[4]);
+	m2 = _mm_load_ps(&h[8]);
+	m3 = _mm_load_ps(&h[12]);
+
+	m4 = _mm_shuffle_ps(m0, m1, _MM_SHUFFLE(0, 2, 0, 2));
+	m5 = _mm_shuffle_ps(m2, m3, _MM_SHUFFLE(0, 2, 0, 2));
+
+	for (int i = 0; i < len; i++) {
+		/* Load (unaligned) input data */
+		m0 = _mm_loadu_ps(&_x[2 * i + 0]);
+		m1 = _mm_loadu_ps(&_x[2 * i + 4]);
+		m2 = _mm_loadu_ps(&_x[2 * i + 8]);
+		m3 = _mm_loadu_ps(&_x[2 * i + 12]);
+
+		m6 = _mm_shuffle_ps(m0, m1, _MM_SHUFFLE(0, 2, 0, 2));
+		m7 = _mm_shuffle_ps(m0, m1, _MM_SHUFFLE(1, 3, 1, 3));
+		m8 = _mm_shuffle_ps(m2, m3, _MM_SHUFFLE(0, 2, 0, 2));
+		m9 = _mm_shuffle_ps(m2, m3, _MM_SHUFFLE(1, 3, 1, 3));
+
+		/* Quad multiply */
+		m6 = _mm_mul_ps(m6, m4);
+		m7 = _mm_mul_ps(m7, m4);
+		m8 = _mm_mul_ps(m8, m5);
+		m9 = _mm_mul_ps(m9, m5);
+
+		/* Sum and store */
+		m6 = _mm_add_ps(m6, m8);
+		m7 = _mm_add_ps(m7, m9);
+		m6 = _mm_hadd_ps(m6, m7);
+		m6 = _mm_hadd_ps(m6, m6);
+
+		_mm_store_ss(&y[2 * i + 0], m6);
+		m6 = _mm_shuffle_ps(m6, m6, _MM_SHUFFLE(0, 3, 2, 1));
+		_mm_store_ss(&y[2 * i + 1], m6);
+	}
+}
+
+/* 12-tap SSE complex-real convolution */
+void sse_conv_real12(const float *x, int x_len,
+		     const float *h, int h_len,
+		     float *y, int y_len,
+		     int start, int len, int step, int offset)
+{
+	/* See NOTE in sse_conv_real4() */
+
+	__m128 m0, m1, m2, m3, m4, m5, m6, m7;
+	__m128 m8, m9, m10, m11, m12, m13, m14;
+
+	const float *_x = &x[2 * (-(h_len - 1) + start)];
+
+	/* Load (aligned) filter taps */
+	m0 = _mm_load_ps(&h[0]);
+	m1 = _mm_load_ps(&h[4]);
+	m2 = _mm_load_ps(&h[8]);
+	m3 = _mm_load_ps(&h[12]);
+	m4 = _mm_load_ps(&h[16]);
+	m5 = _mm_load_ps(&h[20]);
+
+	m12 = _mm_shuffle_ps(m0, m1, _MM_SHUFFLE(0, 2, 0, 2));
+	m13 = _mm_shuffle_ps(m2, m3, _MM_SHUFFLE(0, 2, 0, 2));
+	m14 = _mm_shuffle_ps(m4, m5, _MM_SHUFFLE(0, 2, 0, 2));
+
+	for (int i = 0; i < len; i++) {
+		/* Load (unaligned) input data */
+		m0 = _mm_loadu_ps(&_x[2 * i + 0]);
+		m1 = _mm_loadu_ps(&_x[2 * i + 4]);
+		m2 = _mm_loadu_ps(&_x[2 * i + 8]);
+		m3 = _mm_loadu_ps(&_x[2 * i + 12]);
+
+		m4 = _mm_shuffle_ps(m0, m1, _MM_SHUFFLE(0, 2, 0, 2));
+		m5 = _mm_shuffle_ps(m0, m1, _MM_SHUFFLE(1, 3, 1, 3));
+		m6 = _mm_shuffle_ps(m2, m3, _MM_SHUFFLE(0, 2, 0, 2));
+		m7 = _mm_shuffle_ps(m2, m3, _MM_SHUFFLE(1, 3, 1, 3));
+
+		m0 = _mm_loadu_ps(&_x[2 * i + 16]);
+		m1 = _mm_loadu_ps(&_x[2 * i + 20]);
+
+		m8 = _mm_shuffle_ps(m0, m1, _MM_SHUFFLE(0, 2, 0, 2));
+		m9 = _mm_shuffle_ps(m0, m1, _MM_SHUFFLE(1, 3, 1, 3));
+
+		/* Quad multiply */
+		m0 = _mm_mul_ps(m4, m12);
+		m1 = _mm_mul_ps(m5, m12);
+		m2 = _mm_mul_ps(m6, m13);
+		m3 = _mm_mul_ps(m7, m13);
+		m4 = _mm_mul_ps(m8, m14);
+		m5 = _mm_mul_ps(m9, m14);
+
+		/* Sum and store */
+		m8 = _mm_add_ps(m0, m2);
+		m9 = _mm_add_ps(m1, m3);
+		m10 = _mm_add_ps(m8, m4);
+		m11 = _mm_add_ps(m9, m5);
+
+		m2 = _mm_hadd_ps(m10, m11);
+		m3 = _mm_hadd_ps(m2, m2);
+
+		_mm_store_ss(&y[2 * i + 0], m3);
+		m3 = _mm_shuffle_ps(m3, m3, _MM_SHUFFLE(0, 3, 2, 1));
+		_mm_store_ss(&y[2 * i + 1], m3);
+	}
+}
+
+/* 16-tap SSE complex-real convolution */
+void sse_conv_real16(const float *x, int x_len,
+		     const float *h, int h_len,
+		     float *y, int y_len,
+		     int start, int len, int step, int offset)
+{
+	/* See NOTE in sse_conv_real4() */
+
+	__m128 m0, m1, m2, m3, m4, m5, m6, m7;
+	__m128 m8, m9, m10, m11, m12, m13, m14, m15;
+
+	const float *_x = &x[2 * (-(h_len - 1) + start)];
+
+	/* Load (aligned) filter taps */
+	m0 = _mm_load_ps(&h[0]);
+	m1 = _mm_load_ps(&h[4]);
+	m2 = _mm_load_ps(&h[8]);
+	m3 = _mm_load_ps(&h[12]);
+
+	m4 = _mm_load_ps(&h[16]);
+	m5 = _mm_load_ps(&h[20]);
+	m6 = _mm_load_ps(&h[24]);
+	m7 = _mm_load_ps(&h[28]);
+
+	m12 = _mm_shuffle_ps(m0, m1, _MM_SHUFFLE(0, 2, 0, 2));
+	m13 = _mm_shuffle_ps(m2, m3, _MM_SHUFFLE(0, 2, 0, 2));
+	m14 = _mm_shuffle_ps(m4, m5, _MM_SHUFFLE(0, 2, 0, 2));
+	m15 = _mm_shuffle_ps(m6, m7, _MM_SHUFFLE(0, 2, 0, 2));
+
+	for (int i = 0; i < len; i++) {
+		/* Load (unaligned) input data */
+		m0 = _mm_loadu_ps(&_x[2 * i + 0]);
+		m1 = _mm_loadu_ps(&_x[2 * i + 4]);
+		m2 = _mm_loadu_ps(&_x[2 * i + 8]);
+		m3 = _mm_loadu_ps(&_x[2 * i + 12]);
+
+		m4 = _mm_shuffle_ps(m0, m1, _MM_SHUFFLE(0, 2, 0, 2));
+		m5 = _mm_shuffle_ps(m0, m1, _MM_SHUFFLE(1, 3, 1, 3));
+		m6 = _mm_shuffle_ps(m2, m3, _MM_SHUFFLE(0, 2, 0, 2));
+		m7 = _mm_shuffle_ps(m2, m3, _MM_SHUFFLE(1, 3, 1, 3));
+
+		m0 = _mm_loadu_ps(&_x[2 * i + 16]);
+		m1 = _mm_loadu_ps(&_x[2 * i + 20]);
+		m2 = _mm_loadu_ps(&_x[2 * i + 24]);
+		m3 = _mm_loadu_ps(&_x[2 * i + 28]);
+
+		m8 = _mm_shuffle_ps(m0, m1, _MM_SHUFFLE(0, 2, 0, 2));
+		m9 = _mm_shuffle_ps(m0, m1, _MM_SHUFFLE(1, 3, 1, 3));
+		m10 = _mm_shuffle_ps(m2, m3, _MM_SHUFFLE(0, 2, 0, 2));
+		m11 = _mm_shuffle_ps(m2, m3, _MM_SHUFFLE(1, 3, 1, 3));
+
+		/* Quad multiply */
+		m0 = _mm_mul_ps(m4, m12);
+		m1 = _mm_mul_ps(m5, m12);
+		m2 = _mm_mul_ps(m6, m13);
+		m3 = _mm_mul_ps(m7, m13);
+
+		m4 = _mm_mul_ps(m8, m14);
+		m5 = _mm_mul_ps(m9, m14);
+		m6 = _mm_mul_ps(m10, m15);
+		m7 = _mm_mul_ps(m11, m15);
+
+		/* Sum and store */
+		m8 = _mm_add_ps(m0, m2);
+		m9 = _mm_add_ps(m1, m3);
+		m10 = _mm_add_ps(m4, m6);
+		m11 = _mm_add_ps(m5, m7);
+
+		m0 = _mm_add_ps(m8, m10);
+		m1 = _mm_add_ps(m9, m11);
+		m2 = _mm_hadd_ps(m0, m1);
+		m3 = _mm_hadd_ps(m2, m2);
+
+		_mm_store_ss(&y[2 * i + 0], m3);
+		m3 = _mm_shuffle_ps(m3, m3, _MM_SHUFFLE(0, 3, 2, 1));
+		_mm_store_ss(&y[2 * i + 1], m3);
+	}
+}
+
+/* 20-tap SSE complex-real convolution */
+void sse_conv_real20(const float *x, int x_len,
+		     const float *h, int h_len,
+		     float *y, int y_len,
+		     int start, int len, int step, int offset)
+{
+	/* See NOTE in sse_conv_real4() */
+
+	__m128 m0, m1, m2, m3, m4, m5, m6, m7;
+	__m128 m8, m9, m11, m12, m13, m14, m15;
+
+	const float *_x = &x[2 * (-(h_len - 1) + start)];
+
+	/* Load (aligned) filter taps */
+	m0 = _mm_load_ps(&h[0]);
+	m1 = _mm_load_ps(&h[4]);
+	m2 = _mm_load_ps(&h[8]);
+	m3 = _mm_load_ps(&h[12]);
+	m4 = _mm_load_ps(&h[16]);
+	m5 = _mm_load_ps(&h[20]);
+	m6 = _mm_load_ps(&h[24]);
+	m7 = _mm_load_ps(&h[28]);
+	m8 = _mm_load_ps(&h[32]);
+	m9 = _mm_load_ps(&h[36]);
+
+	m11 = _mm_shuffle_ps(m0, m1, _MM_SHUFFLE(0, 2, 0, 2));
+	m12 = _mm_shuffle_ps(m2, m3, _MM_SHUFFLE(0, 2, 0, 2));
+	m13 = _mm_shuffle_ps(m4, m5, _MM_SHUFFLE(0, 2, 0, 2));
+	m14 = _mm_shuffle_ps(m6, m7, _MM_SHUFFLE(0, 2, 0, 2));
+	m15 = _mm_shuffle_ps(m8, m9, _MM_SHUFFLE(0, 2, 0, 2));
+
+	for (int i = 0; i < len; i++) {
+		/* Multiply-accumulate first 12 taps */
+		m0 = _mm_loadu_ps(&_x[2 * i + 0]);
+		m1 = _mm_loadu_ps(&_x[2 * i + 4]);
+		m2 = _mm_loadu_ps(&_x[2 * i + 8]);
+		m3 = _mm_loadu_ps(&_x[2 * i + 12]);
+		m4 = _mm_loadu_ps(&_x[2 * i + 16]);
+		m5 = _mm_loadu_ps(&_x[2 * i + 20]);
+
+		m6 = _mm_shuffle_ps(m0, m1, _MM_SHUFFLE(0, 2, 0, 2));
+		m7 = _mm_shuffle_ps(m0, m1, _MM_SHUFFLE(1, 3, 1, 3));
+		m8 = _mm_shuffle_ps(m2, m3, _MM_SHUFFLE(0, 2, 0, 2));
+		m9 = _mm_shuffle_ps(m2, m3, _MM_SHUFFLE(1, 3, 1, 3));
+		m0 = _mm_shuffle_ps(m4, m5, _MM_SHUFFLE(0, 2, 0, 2));
+		m1 = _mm_shuffle_ps(m4, m5, _MM_SHUFFLE(1, 3, 1, 3));
+
+		m2 = _mm_mul_ps(m6, m11);
+		m3 = _mm_mul_ps(m7, m11);
+		m4 = _mm_mul_ps(m8, m12);
+		m5 = _mm_mul_ps(m9, m12);
+		m6 = _mm_mul_ps(m0, m13);
+		m7 = _mm_mul_ps(m1, m13);
+
+		m0 = _mm_add_ps(m2, m4);
+		m1 = _mm_add_ps(m3, m5);
+		m8 = _mm_add_ps(m0, m6);
+		m9 = _mm_add_ps(m1, m7);
+
+		/* Multiply-accumulate last 8 taps */
+		m0 = _mm_loadu_ps(&_x[2 * i + 24]);
+		m1 = _mm_loadu_ps(&_x[2 * i + 28]);
+		m2 = _mm_loadu_ps(&_x[2 * i + 32]);
+		m3 = _mm_loadu_ps(&_x[2 * i + 36]);
+
+		m4 = _mm_shuffle_ps(m0, m1, _MM_SHUFFLE(0, 2, 0, 2));
+		m5 = _mm_shuffle_ps(m0, m1, _MM_SHUFFLE(1, 3, 1, 3));
+		m6 = _mm_shuffle_ps(m2, m3, _MM_SHUFFLE(0, 2, 0, 2));
+		m7 = _mm_shuffle_ps(m2, m3, _MM_SHUFFLE(1, 3, 1, 3));
+
+		m0 = _mm_mul_ps(m4, m14);
+		m1 = _mm_mul_ps(m5, m14);
+		m2 = _mm_mul_ps(m6, m15);
+		m3 = _mm_mul_ps(m7, m15);
+
+		m4 = _mm_add_ps(m0, m2);
+		m5 = _mm_add_ps(m1, m3);
+
+		/* Final sum and store */
+		m0 = _mm_add_ps(m8, m4);
+		m1 = _mm_add_ps(m9, m5);
+		m2 = _mm_hadd_ps(m0, m1);
+		m3 = _mm_hadd_ps(m2, m2);
+
+		_mm_store_ss(&y[2 * i + 0], m3);
+		m3 = _mm_shuffle_ps(m3, m3, _MM_SHUFFLE(0, 3, 2, 1));
+		_mm_store_ss(&y[2 * i + 1], m3);
+	}
+}
+
+/* 4*N-tap SSE complex-real convolution */
+void sse_conv_real4n(const float *x, int x_len,
+		     const float *h, int h_len,
+		     float *y, int y_len,
+		     int start, int len, int step, int offset)
+{
+	/* See NOTE in sse_conv_real4() */
+
+	__m128 m0, m1, m2, m4, m5, m6, m7;
+
+	const float *_x = &x[2 * (-(h_len - 1) + start)];
+
+	for (int i = 0; i < len; i++) {
+		/* Zero */
+		m6 = _mm_setzero_ps();
+		m7 = _mm_setzero_ps();
+
+		for (int n = 0; n < h_len / 4; n++) {
+			/* Load (aligned) filter taps */
+			m0 = _mm_load_ps(&h[8 * n + 0]);
+			m1 = _mm_load_ps(&h[8 * n + 4]);
+			m2 = _mm_shuffle_ps(m0, m1, _MM_SHUFFLE(0, 2, 0, 2));
+
+			/* Load (unaligned) input data */
+			m0 = _mm_loadu_ps(&_x[2 * i + 8 * n + 0]);
+			m1 = _mm_loadu_ps(&_x[2 * i + 8 * n + 4]);
+			m4 = _mm_shuffle_ps(m0, m1, _MM_SHUFFLE(0, 2, 0, 2));
+			m5 = _mm_shuffle_ps(m0, m1, _MM_SHUFFLE(1, 3, 1, 3));
+
+			/* Quad multiply */
+			m0 = _mm_mul_ps(m2, m4);
+			m1 = _mm_mul_ps(m2, m5);
+
+			/* Accumulate */
+			m6 = _mm_add_ps(m6, m0);
+			m7 = _mm_add_ps(m7, m1);
+		}
+
+		m0 = _mm_hadd_ps(m6, m7);
+		m0 = _mm_hadd_ps(m0, m0);
+
+		_mm_store_ss(&y[2 * i + 0], m0);
+		m0 = _mm_shuffle_ps(m0, m0, _MM_SHUFFLE(0, 3, 2, 1));
+		_mm_store_ss(&y[2 * i + 1], m0);
+	}
+}
+
+/* 4*N-tap SSE complex-complex convolution */
+void sse_conv_cmplx_4n(const float *x, int x_len,
+		       const float *h, int h_len,
+		       float *y, int y_len,
+		       int start, int len, int step, int offset)
+{
+	/* NOTE: The parameter list of this function has to match the parameter
+	 * list of _base_convolve_complex() in convolve_base.c. This specific
+	 * implementation, ignores some of the parameters of
+	 * _base_convolve_complex(), which are: x_len, y_len, offset, step. */
+
+	__m128 m0, m1, m2, m3, m4, m5, m6, m7;
+
+	const float *_x = &x[2 * (-(h_len - 1) + start)];
+
+	for (int i = 0; i < len; i++) {
+		/* Zero */
+		m6 = _mm_setzero_ps();
+		m7 = _mm_setzero_ps();
+
+		for (int n = 0; n < h_len / 4; n++) {
+			/* Load (aligned) filter taps */
+			m0 = _mm_load_ps(&h[8 * n + 0]);
+			m1 = _mm_load_ps(&h[8 * n + 4]);
+			m2 = _mm_shuffle_ps(m0, m1, _MM_SHUFFLE(0, 2, 0, 2));
+			m3 = _mm_shuffle_ps(m0, m1, _MM_SHUFFLE(1, 3, 1, 3));
+
+			/* Load (unaligned) input data */
+			m0 = _mm_loadu_ps(&_x[2 * i + 8 * n + 0]);
+			m1 = _mm_loadu_ps(&_x[2 * i + 8 * n + 4]);
+			m4 = _mm_shuffle_ps(m0, m1, _MM_SHUFFLE(0, 2, 0, 2));
+			m5 = _mm_shuffle_ps(m0, m1, _MM_SHUFFLE(1, 3, 1, 3));
+
+			/* Quad multiply */
+			m0 = _mm_mul_ps(m2, m4);
+			m1 = _mm_mul_ps(m3, m5);
+
+			m2 = _mm_mul_ps(m2, m5);
+			m3 = _mm_mul_ps(m3, m4);
+
+			/* Sum */
+			m0 = _mm_sub_ps(m0, m1);
+			m2 = _mm_add_ps(m2, m3);
+
+			/* Accumulate */
+			m6 = _mm_add_ps(m6, m0);
+			m7 = _mm_add_ps(m7, m2);
+		}
+
+		m0 = _mm_hadd_ps(m6, m7);
+		m0 = _mm_hadd_ps(m0, m0);
+
+		_mm_store_ss(&y[2 * i + 0], m0);
+		m0 = _mm_shuffle_ps(m0, m0, _MM_SHUFFLE(0, 3, 2, 1));
+		_mm_store_ss(&y[2 * i + 1], m0);
+	}
+}
+
+/* 8*N-tap SSE complex-complex convolution */
+void sse_conv_cmplx_8n(const float *x, int x_len,
+		       const float *h, int h_len,
+		       float *y, int y_len,
+		       int start, int len, int step, int offset)
+{
+	/* See NOTE in sse_conv_cmplx_4n() */
+
+	__m128 m0, m1, m2, m3, m4, m5, m6, m7;
+	__m128 m8, m9, m10, m11, m12, m13, m14, m15;
+
+	const float *_x = &x[2 * (-(h_len - 1) + start)];
+
+	for (int i = 0; i < len; i++) {
+		/* Zero */
+		m12 = _mm_setzero_ps();
+		m13 = _mm_setzero_ps();
+		m14 = _mm_setzero_ps();
+		m15 = _mm_setzero_ps();
+
+		for (int n = 0; n < h_len / 8; n++) {
+			/* Load (aligned) filter taps */
+			m0 = _mm_load_ps(&h[16 * n + 0]);
+			m1 = _mm_load_ps(&h[16 * n + 4]);
+			m2 = _mm_load_ps(&h[16 * n + 8]);
+			m3 = _mm_load_ps(&h[16 * n + 12]);
+
+			m4 = _mm_shuffle_ps(m0, m1, _MM_SHUFFLE(0, 2, 0, 2));
+			m5 = _mm_shuffle_ps(m0, m1, _MM_SHUFFLE(1, 3, 1, 3));
+			m6 = _mm_shuffle_ps(m2, m3, _MM_SHUFFLE(0, 2, 0, 2));
+			m7 = _mm_shuffle_ps(m2, m3, _MM_SHUFFLE(1, 3, 1, 3));
+
+			/* Load (unaligned) input data */
+			m0 = _mm_loadu_ps(&_x[2 * i + 16 * n + 0]);
+			m1 = _mm_loadu_ps(&_x[2 * i + 16 * n + 4]);
+			m2 = _mm_loadu_ps(&_x[2 * i + 16 * n + 8]);
+			m3 = _mm_loadu_ps(&_x[2 * i + 16 * n + 12]);
+
+			m8 = _mm_shuffle_ps(m0, m1, _MM_SHUFFLE(0, 2, 0, 2));
+			m9 = _mm_shuffle_ps(m0, m1, _MM_SHUFFLE(1, 3, 1, 3));
+			m10 = _mm_shuffle_ps(m2, m3, _MM_SHUFFLE(0, 2, 0, 2));
+			m11 = _mm_shuffle_ps(m2, m3, _MM_SHUFFLE(1, 3, 1, 3));
+
+			/* Quad multiply */
+			m0 = _mm_mul_ps(m4, m8);
+			m1 = _mm_mul_ps(m5, m9);
+			m2 = _mm_mul_ps(m6, m10);
+			m3 = _mm_mul_ps(m7, m11);
+
+			m4 = _mm_mul_ps(m4, m9);
+			m5 = _mm_mul_ps(m5, m8);
+			m6 = _mm_mul_ps(m6, m11);
+			m7 = _mm_mul_ps(m7, m10);
+
+			/* Sum */
+			m0 = _mm_sub_ps(m0, m1);
+			m2 = _mm_sub_ps(m2, m3);
+			m4 = _mm_add_ps(m4, m5);
+			m6 = _mm_add_ps(m6, m7);
+
+			/* Accumulate */
+			m12 = _mm_add_ps(m12, m0);
+			m13 = _mm_add_ps(m13, m2);
+			m14 = _mm_add_ps(m14, m4);
+			m15 = _mm_add_ps(m15, m6);
+		}
+
+		m0 = _mm_add_ps(m12, m13);
+		m1 = _mm_add_ps(m14, m15);
+		m2 = _mm_hadd_ps(m0, m1);
+		m2 = _mm_hadd_ps(m2, m2);
+
+		_mm_store_ss(&y[2 * i + 0], m2);
+		m2 = _mm_shuffle_ps(m2, m2, _MM_SHUFFLE(0, 3, 2, 1));
+		_mm_store_ss(&y[2 * i + 1], m2);
+	}
+}
+#endif

Transceiver52M/x86/convolve_sse_3.h

@@ -0,0 +1,68 @@
+/*
+ * SSE Convolution
+ * Copyright (C) 2012, 2013 Thomas Tsou <tom@tsou.cc>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#pragma once
+
+/* 4-tap SSE complex-real convolution */
+void sse_conv_real4(const float *x, int x_len,
+		    const float *h, int h_len,
+		    float *y, int y_len,
+		    int start, int len, int step, int offset);
+
+/* 8-tap SSE complex-real convolution */
+void sse_conv_real8(const float *x, int x_len,
+		    const float *h, int h_len,
+		    float *y, int y_len,
+		    int start, int len, int step, int offset);
+
+/* 12-tap SSE complex-real convolution */
+void sse_conv_real12(const float *x, int x_len,
+		     const float *h, int h_len,
+		     float *y, int y_len,
+		     int start, int len, int step, int offset);
+
+/* 16-tap SSE complex-real convolution */
+void sse_conv_real16(const float *x, int x_len,
+		     const float *h, int h_len,
+		     float *y, int y_len,
+		     int start, int len, int step, int offset);
+
+/* 20-tap SSE complex-real convolution */
+void sse_conv_real20(const float *x, int x_len,
+		     const float *h, int h_len,
+		     float *y, int y_len,
+		     int start, int len, int step, int offset);
+
+/* 4*N-tap SSE complex-real convolution */
+void sse_conv_real4n(const float *x, int x_len,
+		     const float *h, int h_len,
+		     float *y, int y_len,
+		     int start, int len, int step, int offset);
+
+/* 4*N-tap SSE complex-complex convolution */
+void sse_conv_cmplx_4n(const float *x, int x_len,
+		       const float *h, int h_len,
+		       float *y, int y_len,
+		       int start, int len, int step, int offset);
+
+/* 8*N-tap SSE complex-complex convolution */
+void sse_conv_cmplx_8n(const float *x, int x_len,
+		       const float *h, int h_len,
+		       float *y, int y_len,
+		       int start, int len, int step, int offset);

config/ax_ext.m4

@@ -1,221 +0,0 @@
-# ===========================================================================
-#          http://www.gnu.org/software/autoconf-archive/ax_ext.html
-# ===========================================================================
-#
-# SYNOPSIS
-#
-#   AX_EXT
-#
-# DESCRIPTION
-#
-#   Find supported SIMD extensions by requesting cpuid. When an SIMD
-#   extension is found, the -m"simdextensionname" is added to SIMD_FLAGS if
-#   compiler supports it. For example, if "sse2" is available, then "-msse2"
-#   is added to SIMD_FLAGS.
-#
-#   This macro calls:
-#
-#     AC_SUBST(SIMD_FLAGS)
-#
-#   And defines:
-#
-#     HAVE_MMX / HAVE_SSE / HAVE_SSE2 / HAVE_SSE3 / HAVE_SSSE3 / HAVE_SSE4.1 / HAVE_SSE4.2 / HAVE_AVX
-#
-# LICENSE
-#
-#   Copyright (c) 2007 Christophe Tournayre <turn3r@users.sourceforge.net>
-#   Copyright (c) 2013 Michael Petch <mpetch@capp-sysware.com>
-#
-#   Copying and distribution of this file, with or without modification, are
-#   permitted in any medium without royalty provided the copyright notice
-#   and this notice are preserved. This file is offered as-is, without any
-#   warranty.
-
-#serial 12
-
-AC_DEFUN([AX_EXT],
-[
-  AC_REQUIRE([AC_CANONICAL_HOST])
-
-  case $host_cpu in
-    i[[3456]]86*|x86_64*|amd64*)
-
-      AC_REQUIRE([AX_GCC_X86_CPUID])
-      AC_REQUIRE([AX_GCC_X86_AVX_XGETBV])
-
-      AX_GCC_X86_CPUID(0x00000001)
-      ecx=`echo $ax_cv_gcc_x86_cpuid_0x00000001 | cut -d ":" -f 3`
-      edx=`echo $ax_cv_gcc_x86_cpuid_0x00000001 | cut -d ":" -f 4`
-
-      AC_CACHE_CHECK([whether mmx is supported], [ax_cv_have_mmx_ext],
-      [
-        ax_cv_have_mmx_ext=no
-        if test "$((0x$edx>>23&0x01))" = 1; then
-          ax_cv_have_mmx_ext=yes
-        fi
-      ])
-
-      AC_CACHE_CHECK([whether sse is supported], [ax_cv_have_sse_ext],
-      [
-        ax_cv_have_sse_ext=no
-        if test "$((0x$edx>>25&0x01))" = 1; then
-          ax_cv_have_sse_ext=yes
-        fi
-      ])
-
-      AC_CACHE_CHECK([whether sse2 is supported], [ax_cv_have_sse2_ext],
-      [
-        ax_cv_have_sse2_ext=no
-        if test "$((0x$edx>>26&0x01))" = 1; then
-          ax_cv_have_sse2_ext=yes
-        fi
-      ])
-
-      AC_CACHE_CHECK([whether sse3 is supported], [ax_cv_have_sse3_ext],
-      [
-        ax_cv_have_sse3_ext=no
-        if test "$((0x$ecx&0x01))" = 1; then
-          ax_cv_have_sse3_ext=yes
-        fi
-      ])
-
-      AC_CACHE_CHECK([whether ssse3 is supported], [ax_cv_have_ssse3_ext],
-      [
-        ax_cv_have_ssse3_ext=no
-        if test "$((0x$ecx>>9&0x01))" = 1; then
-          ax_cv_have_ssse3_ext=yes
-        fi
-      ])
-
-      AC_CACHE_CHECK([whether sse4.1 is supported], [ax_cv_have_sse41_ext],
-      [
-        ax_cv_have_sse41_ext=no
-        if test "$((0x$ecx>>19&0x01))" = 1; then
-          ax_cv_have_sse41_ext=yes
-        fi
-      ])
-
-      AC_CACHE_CHECK([whether sse4.2 is supported], [ax_cv_have_sse42_ext],
-      [
-        ax_cv_have_sse42_ext=no
-        if test "$((0x$ecx>>20&0x01))" = 1; then
-          ax_cv_have_sse42_ext=yes
-        fi
-      ])
-
-      AC_CACHE_CHECK([whether avx is supported by processor], [ax_cv_have_avx_cpu_ext],
-      [
-        ax_cv_have_avx_cpu_ext=no
-        if test "$((0x$ecx>>28&0x01))" = 1; then
-          ax_cv_have_avx_cpu_ext=yes
-        fi
-      ])
-
-      if test x"$ax_cv_have_avx_cpu_ext" = x"yes"; then
-        AX_GCC_X86_AVX_XGETBV(0x00000000)
-
-        xgetbv_eax="0"
-        if test x"$ax_cv_gcc_x86_avx_xgetbv_0x00000000" != x"unknown"; then
-          xgetbv_eax=`echo $ax_cv_gcc_x86_avx_xgetbv_0x00000000 | cut -d ":" -f 1`
-        fi
-
-        AC_CACHE_CHECK([whether avx is supported by operating system], [ax_cv_have_avx_ext],
-        [
-          ax_cv_have_avx_ext=no
-
-          if test "$((0x$ecx>>27&0x01))" = 1; then
-            if test "$((0x$xgetbv_eax&0x6))" = 6; then
-              ax_cv_have_avx_ext=yes
-            fi
-          fi
-        ])
-        if test x"$ax_cv_have_avx_ext" = x"no"; then
-          AC_MSG_WARN([Your processor supports AVX, but your operating system doesn't])
-        fi
-      fi
-
-      if test "$ax_cv_have_mmx_ext" = yes; then
-        AX_CHECK_COMPILE_FLAG(-mmmx, ax_cv_support_mmx_ext=yes, [])
-        if test x"$ax_cv_support_mmx_ext" = x"yes"; then
-          SIMD_FLAGS="$SIMD_FLAGS -mmmx"
-          AC_DEFINE(HAVE_MMX,,[Support mmx instructions])
-        else
-          AC_MSG_WARN([Your processor supports mmx instructions but not your compiler, can you try another compiler?])
-        fi
-      fi
-
-      if test "$ax_cv_have_sse_ext" = yes; then
-        AX_CHECK_COMPILE_FLAG(-msse, ax_cv_support_sse_ext=yes, [])
-        if test x"$ax_cv_support_sse_ext" = x"yes"; then
-          SIMD_FLAGS="$SIMD_FLAGS -msse"
-          AC_DEFINE(HAVE_SSE,,[Support SSE (Streaming SIMD Extensions) instructions])
-        else
-          AC_MSG_WARN([Your processor supports sse instructions but not your compiler, can you try another compiler?])
-        fi
-      fi
-
-      if test "$ax_cv_have_sse2_ext" = yes; then
-        AX_CHECK_COMPILE_FLAG(-msse2, ax_cv_support_sse2_ext=yes, [])
-        if test x"$ax_cv_support_sse2_ext" = x"yes"; then
-          SIMD_FLAGS="$SIMD_FLAGS -msse2"
-          AC_DEFINE(HAVE_SSE2,,[Support SSE2 (Streaming SIMD Extensions 2) instructions])
-        else
-          AC_MSG_WARN([Your processor supports sse2 instructions but not your compiler, can you try another compiler?])
-        fi
-      fi
-
-      if test "$ax_cv_have_sse3_ext" = yes; then
-        AX_CHECK_COMPILE_FLAG(-msse3, ax_cv_support_sse3_ext=yes, [])
-        if test x"$ax_cv_support_sse3_ext" = x"yes"; then
-          SIMD_FLAGS="$SIMD_FLAGS -msse3"
-          AC_DEFINE(HAVE_SSE3,,[Support SSE3 (Streaming SIMD Extensions 3) instructions])
-        else
-          AC_MSG_WARN([Your processor supports sse3 instructions but not your compiler, can you try another compiler?])
-        fi
-      fi
-
-      if test "$ax_cv_have_ssse3_ext" = yes; then
-        AX_CHECK_COMPILE_FLAG(-mssse3, ax_cv_support_ssse3_ext=yes, [])
-        if test x"$ax_cv_support_ssse3_ext" = x"yes"; then
-          SIMD_FLAGS="$SIMD_FLAGS -mssse3"
-          AC_DEFINE(HAVE_SSSE3,,[Support SSSE3 (Supplemental Streaming SIMD Extensions 3) instructions])
-        else
-          AC_MSG_WARN([Your processor supports ssse3 instructions but not your compiler, can you try another compiler?])
-        fi
-      fi
-
-      if test "$ax_cv_have_sse41_ext" = yes; then
-        AX_CHECK_COMPILE_FLAG(-msse4.1, ax_cv_support_sse41_ext=yes, [])
-        if test x"$ax_cv_support_sse41_ext" = x"yes"; then
-          SIMD_FLAGS="$SIMD_FLAGS -msse4.1"
-          AC_DEFINE(HAVE_SSE4_1,,[Support SSSE4.1 (Streaming SIMD Extensions 4.1) instructions])
-        else
-          AC_MSG_WARN([Your processor supports sse4.1 instructions but not your compiler, can you try another compiler?])
-        fi
-      fi
-
-      if test "$ax_cv_have_sse42_ext" = yes; then
-        AX_CHECK_COMPILE_FLAG(-msse4.2, ax_cv_support_sse42_ext=yes, [])
-        if test x"$ax_cv_support_sse42_ext" = x"yes"; then
-          SIMD_FLAGS="$SIMD_FLAGS -msse4.2"
-          AC_DEFINE(HAVE_SSE4_2,,[Support SSSE4.2 (Streaming SIMD Extensions 4.2) instructions])
-        else
-          AC_MSG_WARN([Your processor supports sse4.2 instructions but not your compiler, can you try another compiler?])
-        fi
-      fi
-
-      if test "$ax_cv_have_avx_ext" = yes; then
-        AX_CHECK_COMPILE_FLAG(-mavx, ax_cv_support_avx_ext=yes, [])
-        if test x"$ax_cv_support_avx_ext" = x"yes"; then
-          SIMD_FLAGS="$SIMD_FLAGS -mavx"
-          AC_DEFINE(HAVE_AVX,,[Support AVX (Advanced Vector Extensions) instructions])
-        else
-          AC_MSG_WARN([Your processor supports avx instructions but not your compiler, can you try another compiler?])
-        fi
-      fi
-
-  ;;
-  esac
-
-  AC_SUBST(SIMD_FLAGS)
-])

config/ax_sse.m4

@@ -0,0 +1,75 @@
+# ===========================================================================
+#          http://www.gnu.org/software/autoconf-archive/ax_ext.html
+# ===========================================================================
+#
+# SYNOPSIS
+#
+#   AX_EXT
+#
+# DESCRIPTION
+#
+#   Find supported SIMD extensions by requesting cpuid. When an SIMD
+#   extension is found, the -m"simdextensionname" is added to SIMD_FLAGS if
+#   compiler supports it. For example, if "sse2" is available, then "-msse2"
+#   is added to SIMD_FLAGS.
+#
+#   This macro calls:
+#
+#     AC_SUBST(SIMD_FLAGS)
+#
+#   And defines:
+#
+#     HAVE_MMX / HAVE_SSE / HAVE_SSE2 / HAVE_SSE3 / HAVE_SSSE3 / HAVE_SSE4.1 / HAVE_SSE4.2 / HAVE_AVX
+#
+# LICENSE
+#
+#   Copyright (c) 2007 Christophe Tournayre <turn3r@users.sourceforge.net>
+#   Copyright (c) 2013 Michael Petch <mpetch@capp-sysware.com>
+#
+#   Copying and distribution of this file, with or without modification, are
+#   permitted in any medium without royalty provided the copyright notice
+#   and this notice are preserved. This file is offered as-is, without any
+#   warranty.
+#
+# NOTE: The functionality that requests the cpuid has been stripped because
+#       this project detects the CPU capabilities during runtime. However, we
+#       still need to check if the compiler supports the requested SIMD flag
+
+#serial 12
+
+AC_DEFUN([AX_SSE],
+[
+  AC_REQUIRE([AC_CANONICAL_HOST])
+
+  case $host_cpu in
+    i[[3456]]86*|x86_64*|amd64*)
+
+      AC_REQUIRE([AX_GCC_X86_CPUID])
+      AC_REQUIRE([AX_GCC_X86_AVX_XGETBV])
+
+      AX_GCC_X86_CPUID(0x00000001)
+
+      AX_CHECK_COMPILE_FLAG(-msse3, ax_cv_support_sse3_ext=yes, [])
+      if test x"$ax_cv_support_sse3_ext" = x"yes"; then
+        SIMD_FLAGS="$SIMD_FLAGS -msse3"
+        AC_DEFINE(HAVE_SSE3,,[Support SSE3 (Streaming SIMD Extensions 3) instructions])
+	AM_CONDITIONAL(HAVE_SSE3, true)
+      else
+        AC_MSG_WARN([Your compiler does not support sse3 instructions, can you try another compiler?])
+	AM_CONDITIONAL(HAVE_SSE3, false)
+      fi
+
+      AX_CHECK_COMPILE_FLAG(-msse4.1, ax_cv_support_sse41_ext=yes, [])
+      if test x"$ax_cv_support_sse41_ext" = x"yes"; then
+        SIMD_FLAGS="$SIMD_FLAGS -msse4.1"
+        AC_DEFINE(HAVE_SSE4_1,,[Support SSE4.1 (Streaming SIMD Extensions 4.1) instructions])
+	AM_CONDITIONAL(HAVE_SSE4_1, true)
+      else
+        AC_MSG_WARN([Your compiler does not support sse4.1 instructions, can you try another compiler?])
+	AM_CONDITIONAL(HAVE_SSE4_1, false)
+      fi
+  ;;
+  esac
+
+  AC_SUBST(SIMD_FLAGS)
+])

configure.ac

@@ -97,11 +97,15 @@ AS_IF([test "x$with_usrp1" = "xyes"], [
 ])
 
 AS_IF([test "x$with_usrp1" != "xyes"],[
-    PKG_CHECK_MODULES(UHD, uhd >= 003.009,
-        [AC_DEFINE(USE_UHD_3_9, 1, UHD version 3.9.0 or higher)],
-        [PKG_CHECK_MODULES(UHD, uhd >= 003.005.004)]
+    PKG_CHECK_MODULES(UHD, uhd >= 003.011,
+        [AC_DEFINE(USE_UHD_3_11, 1, UHD version 3.11.0 or higher)],
+        [PKG_CHECK_MODULES(UHD, uhd >= 003.009,
+            [AC_DEFINE(USE_UHD_3_9, 1, UHD version 3.9.0 or higher)],
+            [PKG_CHECK_MODULES(UHD, uhd >= 003.005)]
+        )]
     )
     AC_DEFINE(USE_UHD, 1, All UHD versions)
+    PKG_CHECK_MODULES(FFTWF, fftw3f)
 ])
 
 AS_IF([test "x$with_singledb" = "xyes"], [
@@ -110,14 +114,23 @@ AS_IF([test "x$with_singledb" = "xyes"], [
 
 # Find and define supported SIMD extensions
 AS_IF([test "x$with_sse" != "xno"], [
-    AX_EXT
+    AX_SSE
+], [
+    AM_CONDITIONAL(HAVE_SSE3, false)
+    AM_CONDITIONAL(HAVE_SSE4_1, false)
 ])
 
 AM_CONDITIONAL(USRP1, [test "x$with_usrp1" = "xyes"])
 AM_CONDITIONAL(ARCH_ARM, [test "x$with_neon" = "xyes" || test "x$with_neon_vfpv4" = "xyes"])
 AM_CONDITIONAL(ARCH_ARM_A15, [test "x$with_neon_vfpv4" = "xyes"])
 
+AC_CHECK_LIB(sqlite3, sqlite3_open, , AC_MSG_ERROR(sqlite3 is not available))
+
 PKG_CHECK_MODULES(LIBUSB, libusb-1.0)
+PKG_CHECK_MODULES(SQLITE3, sqlite3)
+
+AC_CHECK_HEADER([boost/config.hpp],[],
+    [AC_MSG_ERROR([boost/config.hpp not found, install e.g. libboost-dev])])
 
 dnl Output files
 AC_CONFIG_FILES([\
@@ -127,7 +140,6 @@ AC_CONFIG_FILES([\
     Transceiver52M/Makefile \
     Transceiver52M/arm/Makefile \
     Transceiver52M/x86/Makefile \
-    sqlite3/Makefile \
 ])
 
 AC_OUTPUT

contrib/jenkins.sh

@@ -0,0 +1,7 @@
+#!/bin/sh
+set -ex
+autoreconf --install --force
+./configure
+$MAKE $PARALLEL_MAKE
+$MAKE check \
+  || cat-testlogs.sh

debian/changelog

@@ -1,33 +1,3 @@
-osmo-trx (0.1.10~3) trusty; urgency=medium
-
-  * 737fc25 transceiver: WIP: Set default max delay to 2 samples.
-  * 58f5333 sigProcLib: Change number of head bits in detectRACHBurst() from 4 to 8.
-  * ceb4171 transceiver: Add an option to emulate a RACH delay in random filler mode.
-  * 5bf037b transceiver: Log channel number in DEBUG output of demoded bursts.
-  * a057c7d radioInterface: Initialize power scale with a meaningful default.
-  * 3b093bb uhd: Set minimum UHD version requirement for E3XX
-  * 0fe41a5 uhd: Set default Tx sampling to 4 sps
-  * a5e0f1c uhd: Update default E3XX settings
-  * 2c650a6 common: Add mandatory length field to UDP receive calls
-  * d4555f2 common: Restrict UDP binding to localhost only
-
- -- Alexander Chemeris <Alexander.Chemeris@gmail.com>  Sat, 18 Jun 2016 16:07:17 +0300
-
-osmo-trx (0.1.10~2) trusty; urgency=medium
-
-  * c88385c makefile: Fix build from an external path.
-  * 0479562 EDGE: Fix demodulation slicer input
-  * d2b0703 uhd: Correct timing alignment in 8-PSK and GMSK downlink bursts
-
- -- Alexander Chemeris <Alexander.Chemeris@gmail.com>  Sat, 30 Apr 2016 01:57:45 +0300
-
-osmo-trx (0.1.10~1) trusty; urgency=medium
-
-  * some EDGE support in master
-  * fairwaves/rach-filler branch
-
- -- Kirill Zakharenko <earwin@gmail.com>  Sun, 27 Mar 2016 19:37:39 +0100
-
 osmo-trx (0.1.9) trusty; urgency=medium
 
   * Ask Ivan, really
@@ -36,6 +6,6 @@ osmo-trx (0.1.9) trusty; urgency=medium
 
 osmo-trx (0.1.8) precise; urgency=low
 
-     * Initial release
+     * Initial release (Closes: #nnnn) <nnnn is the bug number of your ITP
 
  -- Ivan Klyuchnikov <Ivan.Kluchnikov@fairwaves.ru>  Sun, 9 Mar 2014 14:10:10 +0400

debian/control

@@ -1,17 +1,41 @@
 Source: osmo-trx
-Maintainer: Ivan Klyuchnikov <ivan.kluchnikov@fairwaves.ru>
 Section: net
 Priority: optional
-Standards-Version: 3.9.3
-Build-Depends: debhelper (>= 9), autotools-dev, libdbd-sqlite3, pkg-config, dh-autoreconf, libuhd-dev, libusb-1.0-0-dev, libboost-all-dev, hardening-wrapper
-Homepage: http://openbsc.osmocom.org/trac/wiki/OsmoTRX
-Vcs-Git: git://git.osmocom.org/osmo-trx
+Maintainer: Ivan Klyuchnikov <ivan.kluchnikov@fairwaves.ru>
+Build-Depends: debhelper (>= 9),
+               autotools-dev,
+               autoconf-archive,
+               libdbd-sqlite3,
+               libsqlite3-dev,
+               pkg-config,
+               dh-autoreconf,
+               libuhd-dev,
+               libusb-1.0-0-dev,
+               libboost-all-dev,
+               libfftw3-dev
+Standards-Version: 3.9.6
 Vcs-Browser: http://cgit.osmocom.org/osmo-trx
+Vcs-Git: git://git.osmocom.org/osmo-trx
+Homepage: https://projects.osmocom.org/projects/osmotrx
 
 Package: osmo-trx
 Architecture: any
 Depends: ${shlibs:Depends}, ${misc:Depends}, libdbd-sqlite3
-Description: OsmoTRX is a software-defined radio transceiver that implements the Layer 1 physical layer of a BTS
+Description: SDR transceiver that implements Layer 1 of a GSM BTS
+ OsmoTRX is a software-defined radio transceiver that implements the Layer 1
+ physical layer of a BTS comprising the following 3GPP specifications:
+ .
+ TS 05.01 "Physical layer on the radio path"
+ TS 05.02 "Multiplexing and Multiple Access on the Radio Path"
+ TS 05.04 "Modulation"
+ TS 05.10 "Radio subsystem synchronization"
+ .
+ In this context, BTS is "Base transceiver station". It's the stations that
+ connect mobile phones to the mobile network.
+ .
+ 3GPP is the "3rd Generation Partnership Project" which is the collaboration
+ between different telecommunication associations for developing new
+ generations of mobile phone networks. (post-2G/GSM)
 
 Package: osmo-trx-dbg
 Architecture: any
@@ -20,5 +44,3 @@ Priority: extra
 Depends: osmo-trx (= ${binary:Version}), ${misc:Depends}
 Description: Debug symbols for the osmo-trx
  Make debugging possible
-
-

debian/copyright

@@ -1,25 +1,161 @@
-The Debian packaging is:
+Format: http://www.debian.org/doc/packaging-manuals/copyright-format/1.0/
+Upstream-Name: OsmoTRX
+Source: http://cgit.osmocom.org/osmo-trx/
+Files-Excluded: Transceiver52M/std_inband.rbf
 
-    Copyright (C) 2014 Max <max.suraev@fairwaves.ru>
+Files: *
+Copyright: 2008-2013 Free Software Foundation
+           2010 Kestrel Signal Processing, Inc.
+           2010-2012 Range Networks, Inc.
+License: AGPL-3+
 
-It was downloaded from:
+Files: Transceiver52M/arm/*
+       Transceiver52M/x86/*
+       Transceiver52M/common/*
+       Transceiver52M/Resampler.cpp
+       Transceiver52M/Resampler.h
+       Transceiver52M/osmo-trx.cpp
+       Transceiver52M/radioInterfaceDiversity.cpp
+Copyright: 2012-2013 Thomas Tsou <tom@tsou.cc>
+License: LGPL-2.1+
 
-    git://git.osmocom.org/osmo-trx
+Files: config/ax_check_compile_flag.m4
+Copyright: 2008 Guido U. Draheim <guidod@gmx.de>
+           2011 Maarten Bosmans <mkbosmans@gmail.com>
+License: GPL-3+
 
-Upstream Authors:
+Files: config/ax_gcc_x86_cpuid.m4
+Copyright: 2008 Steven G. Johnson <stevenj@alum.mit.edu>
+           2008 Matteo Frigo
+License: GPL-3+
 
-    Thomas Tsou <tom@tsou.cc>
-    David A. Burgess <dburgess@kestrelsp.com>
-    Harvind S. Samra <hssamra@kestrelsp.com>
-    Raffi Sevlian <raffisev@gmail.com>
+Files: config/ax_ext.m4
+Copyright: 2007 Christophe Tournayre <turn3r@users.sourceforge.net>
+           2013 Michael Petch <mpetch@capp-sysware.com>
+License: license_for_ax_ext_m4
 
-Copyright:
+Files: config/ax_gcc_x86_avx_xgetbv.m4
+Copyright: 2013 Michael Petch <mpetch@capp-sysware.com>
+License: GPL-3+
 
-     Copyright (C) 2012-2013 Thomas Tsou <tom@tsou.cc>
-     Copyright (C) 2011 Range Networks, Inc.
-     Copyright (C) 2008-2011 Free Software Foundation, Inc.
+Files: CommonLibs/Makefile.am
+       GSM/Makefile.am
+       Transceiver52M/Makefile.am
+       Transceiver52M/Transceiver.h
+       Transceiver52M/Transceiver.cpp
+Copyright: 2008-2010 Free Software Foundation
+           2010-2012 Range Networks, Inc.
+License: GPL-3+
 
-License:
+Files: autogen.sh
+Copyright: 2005-2009 United States Government as represented by
+                     the U.S. Army Research Laboratory.
+License: BSD-3-clause
 
-    GNU Affero General Public License, Version 3
+Files: CommonLibs/sqlite3util.cpp
+Copyright: 2010 Kestrel Signal Processing Inc.
+License: none
+ No license described for file.
+Comment: In the previous version of the file in the git repository
+ at upstream it is written:
+   Written by David A. Burgess, Kestrel Signal Processing, Inc., 2010
+   The author disclaims copyright to this source code.
+ In the git log, this is written:
+   I do not claim any copyright over this change, as it's very basic.
+   Looking forward to see it merged into mainline.
+ See revision e766abbf82f02473038a83fd2f78befd08544cab at
+ https://github.com/osmocom/osmo-trx
 
+Files: debian/*
+Copyright: 2015 Ruben Undheim <ruben.undheim@gmail.com>
+License: GPL-3+
+
+
+License: AGPL-3+
+ This program is free software: you can redistribute it and/or modify
+ it under the terms of the GNU Affero General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+ .
+ 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 Affero General Public License for more details.
+ .
+ You should have received a copy of the GNU Affero General Public License
+ along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+
+License: GPL-3+
+ This package 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; either version 3 of the License, or
+ (at your option) any later version.
+ .
+ This package 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 for more details.
+ .
+ You should have received a copy of the GNU General Public License
+ along with this program. If not, see <http://www.gnu.org/licenses/>
+ .
+ On Debian systems, the complete text of the GNU General
+ Public License version 3 can be found in "/usr/share/common-licenses/GPL-3".
+
+
+License: LGPL-2.1+
+ This library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Lesser General Public
+ License as published by the Free Software Foundation; either
+ version 2.1 of the License, or (at your option) any later version.
+ .
+ This library 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
+ Lesser General Public License for more details.
+ .
+ You should have received a copy of the GNU Lesser General Public
+ License along with this program. If not, see
+ <http://www.gnu.org/licenses/>
+ .
+ On Debian systems, the complete text of the GNU Lesser General
+ Public License version 2.1 can be found in
+ "/usr/share/common-licenses/LGPL-2.1".
+
+
+License: license_for_ax_ext_m4
+ Copying and distribution of this file, with or without modification, are
+ permitted in any medium without royalty provided the copyright notice
+ and this notice are preserved. This file is offered as-is, without any
+ warranty.
+
+
+License: BSD-3-clause
+ Redistribution and use in source and binary forms, with or without
+ modification, are permitted provided that the following conditions
+ are met:
+ .
+ 1. Redistributions of source code must retain the above copyright
+ notice, this list of conditions and the following disclaimer.
+ .
+ 2. Redistributions in binary form must reproduce the above
+ copyright notice, this list of conditions and the following
+ disclaimer in the documentation and/or other materials provided
+ with the distribution.
+ .
+ 3. The name of the author may not be used to endorse or promote
+ products derived from this software without specific prior written
+ permission.
+ .
+ THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS
+ OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
+ DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
+ GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

debian/rules

@@ -1,13 +1,10 @@
 #!/usr/bin/make -f
 
-DEB_BUILD_HARDENING=1
+export DEB_BUILD_MAINT_OPTIONS = hardening=+all
 
 %:
 	dh $@ --with autoreconf
 
-override_dh_auto_configure:
-	dh_auto_configure -- --without-sse CFLAGS="-DHAVE_SSE3 -march=atom -mtune=atom -O2" CXXFLAGS="-DHAVE_SSE3 -march=atom -mtune=atom -O2"
-
 override_dh_shlibdeps:
 	dh_shlibdeps --dpkg-shlibdeps-params=--ignore-missing-info
 

sqlite3/Makefile.am

@@ -1,34 +0,0 @@
-#
-# Copyright 2008, 2009, 2010 Free Software Foundation, Inc.
-#
-# This software is distributed under the terms of the GNU Public License.
-# See the COPYING file in the main directory for details.
-#
-# 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, either version 3 of the License, or
-# (at your option) any later version.
-#
-# 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 for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with this program.  If not, see <http://www.gnu.org/licenses/>.
-#
-
-include $(top_srcdir)/Makefile.common
-
-AM_CPPFLAGS = $(STD_DEFINES_AND_INCLUDES)
-AM_CXXFLAGS = -Wall -lpthread -ldl
-
-noinst_LTLIBRARIES = libsqlite.la
-
-libsqlite_la_SOURCES = \
-	sqlite3.c
-
-noinst_HEADERS = \
-	sqlite3.h \
-	sqlite3ext.h
-

sqlite3/sqlite3ext.h

@@ -1,447 +0,0 @@
-/*
-** 2006 June 7
-**
-** The author disclaims copyright to this source code.  In place of
-** a legal notice, here is a blessing:
-**
-**    May you do good and not evil.
-**    May you find forgiveness for yourself and forgive others.
-**    May you share freely, never taking more than you give.
-**
-*************************************************************************
-** This header file defines the SQLite interface for use by
-** shared libraries that want to be imported as extensions into
-** an SQLite instance.  Shared libraries that intend to be loaded
-** as extensions by SQLite should #include this file instead of 
-** sqlite3.h.
-*/
-#ifndef _SQLITE3EXT_H_
-#define _SQLITE3EXT_H_
-#include "sqlite3.h"
-
-typedef struct sqlite3_api_routines sqlite3_api_routines;
-
-/*
-** The following structure holds pointers to all of the SQLite API
-** routines.
-**
-** WARNING:  In order to maintain backwards compatibility, add new
-** interfaces to the end of this structure only.  If you insert new
-** interfaces in the middle of this structure, then older different
-** versions of SQLite will not be able to load each others' shared
-** libraries!
-*/
-struct sqlite3_api_routines {
-  void * (*aggregate_context)(sqlite3_context*,int nBytes);
-  int  (*aggregate_count)(sqlite3_context*);
-  int  (*bind_blob)(sqlite3_stmt*,int,const void*,int n,void(*)(void*));
-  int  (*bind_double)(sqlite3_stmt*,int,double);
-  int  (*bind_int)(sqlite3_stmt*,int,int);
-  int  (*bind_int64)(sqlite3_stmt*,int,sqlite_int64);
-  int  (*bind_null)(sqlite3_stmt*,int);
-  int  (*bind_parameter_count)(sqlite3_stmt*);
-  int  (*bind_parameter_index)(sqlite3_stmt*,const char*zName);
-  const char * (*bind_parameter_name)(sqlite3_stmt*,int);
-  int  (*bind_text)(sqlite3_stmt*,int,const char*,int n,void(*)(void*));
-  int  (*bind_text16)(sqlite3_stmt*,int,const void*,int,void(*)(void*));
-  int  (*bind_value)(sqlite3_stmt*,int,const sqlite3_value*);
-  int  (*busy_handler)(sqlite3*,int(*)(void*,int),void*);
-  int  (*busy_timeout)(sqlite3*,int ms);
-  int  (*changes)(sqlite3*);
-  int  (*close)(sqlite3*);
-  int  (*collation_needed)(sqlite3*,void*,void(*)(void*,sqlite3*,
-                           int eTextRep,const char*));
-  int  (*collation_needed16)(sqlite3*,void*,void(*)(void*,sqlite3*,
-                             int eTextRep,const void*));
-  const void * (*column_blob)(sqlite3_stmt*,int iCol);
-  int  (*column_bytes)(sqlite3_stmt*,int iCol);
-  int  (*column_bytes16)(sqlite3_stmt*,int iCol);
-  int  (*column_count)(sqlite3_stmt*pStmt);
-  const char * (*column_database_name)(sqlite3_stmt*,int);
-  const void * (*column_database_name16)(sqlite3_stmt*,int);
-  const char * (*column_decltype)(sqlite3_stmt*,int i);
-  const void * (*column_decltype16)(sqlite3_stmt*,int);
-  double  (*column_double)(sqlite3_stmt*,int iCol);
-  int  (*column_int)(sqlite3_stmt*,int iCol);
-  sqlite_int64  (*column_int64)(sqlite3_stmt*,int iCol);
-  const char * (*column_name)(sqlite3_stmt*,int);
-  const void * (*column_name16)(sqlite3_stmt*,int);
-  const char * (*column_origin_name)(sqlite3_stmt*,int);
-  const void * (*column_origin_name16)(sqlite3_stmt*,int);
-  const char * (*column_table_name)(sqlite3_stmt*,int);
-  const void * (*column_table_name16)(sqlite3_stmt*,int);
-  const unsigned char * (*column_text)(sqlite3_stmt*,int iCol);
-  const void * (*column_text16)(sqlite3_stmt*,int iCol);
-  int  (*column_type)(sqlite3_stmt*,int iCol);
-  sqlite3_value* (*column_value)(sqlite3_stmt*,int iCol);
-  void * (*commit_hook)(sqlite3*,int(*)(void*),void*);
-  int  (*complete)(const char*sql);
-  int  (*complete16)(const void*sql);
-  int  (*create_collation)(sqlite3*,const char*,int,void*,
-                           int(*)(void*,int,const void*,int,const void*));
-  int  (*create_collation16)(sqlite3*,const void*,int,void*,
-                             int(*)(void*,int,const void*,int,const void*));
-  int  (*create_function)(sqlite3*,const char*,int,int,void*,
-                          void (*xFunc)(sqlite3_context*,int,sqlite3_value**),
-                          void (*xStep)(sqlite3_context*,int,sqlite3_value**),
-                          void (*xFinal)(sqlite3_context*));
-  int  (*create_function16)(sqlite3*,const void*,int,int,void*,
-                            void (*xFunc)(sqlite3_context*,int,sqlite3_value**),
-                            void (*xStep)(sqlite3_context*,int,sqlite3_value**),
-                            void (*xFinal)(sqlite3_context*));
-  int (*create_module)(sqlite3*,const char*,const sqlite3_module*,void*);
-  int  (*data_count)(sqlite3_stmt*pStmt);
-  sqlite3 * (*db_handle)(sqlite3_stmt*);
-  int (*declare_vtab)(sqlite3*,const char*);
-  int  (*enable_shared_cache)(int);
-  int  (*errcode)(sqlite3*db);
-  const char * (*errmsg)(sqlite3*);
-  const void * (*errmsg16)(sqlite3*);
-  int  (*exec)(sqlite3*,const char*,sqlite3_callback,void*,char**);
-  int  (*expired)(sqlite3_stmt*);
-  int  (*finalize)(sqlite3_stmt*pStmt);
-  void  (*free)(void*);
-  void  (*free_table)(char**result);
-  int  (*get_autocommit)(sqlite3*);
-  void * (*get_auxdata)(sqlite3_context*,int);
-  int  (*get_table)(sqlite3*,const char*,char***,int*,int*,char**);
-  int  (*global_recover)(void);
-  void  (*interruptx)(sqlite3*);
-  sqlite_int64  (*last_insert_rowid)(sqlite3*);
-  const char * (*libversion)(void);
-  int  (*libversion_number)(void);
-  void *(*malloc)(int);
-  char * (*mprintf)(const char*,...);
-  int  (*open)(const char*,sqlite3**);
-  int  (*open16)(const void*,sqlite3**);
-  int  (*prepare)(sqlite3*,const char*,int,sqlite3_stmt**,const char**);
-  int  (*prepare16)(sqlite3*,const void*,int,sqlite3_stmt**,const void**);
-  void * (*profile)(sqlite3*,void(*)(void*,const char*,sqlite_uint64),void*);
-  void  (*progress_handler)(sqlite3*,int,int(*)(void*),void*);
-  void *(*realloc)(void*,int);
-  int  (*reset)(sqlite3_stmt*pStmt);
-  void  (*result_blob)(sqlite3_context*,const void*,int,void(*)(void*));
-  void  (*result_double)(sqlite3_context*,double);
-  void  (*result_error)(sqlite3_context*,const char*,int);
-  void  (*result_error16)(sqlite3_context*,const void*,int);
-  void  (*result_int)(sqlite3_context*,int);
-  void  (*result_int64)(sqlite3_context*,sqlite_int64);
-  void  (*result_null)(sqlite3_context*);
-  void  (*result_text)(sqlite3_context*,const char*,int,void(*)(void*));
-  void  (*result_text16)(sqlite3_context*,const void*,int,void(*)(void*));
-  void  (*result_text16be)(sqlite3_context*,const void*,int,void(*)(void*));
-  void  (*result_text16le)(sqlite3_context*,const void*,int,void(*)(void*));
-  void  (*result_value)(sqlite3_context*,sqlite3_value*);
-  void * (*rollback_hook)(sqlite3*,void(*)(void*),void*);
-  int  (*set_authorizer)(sqlite3*,int(*)(void*,int,const char*,const char*,
-                         const char*,const char*),void*);
-  void  (*set_auxdata)(sqlite3_context*,int,void*,void (*)(void*));
-  char * (*snprintf)(int,char*,const char*,...);
-  int  (*step)(sqlite3_stmt*);
-  int  (*table_column_metadata)(sqlite3*,const char*,const char*,const char*,
-                                char const**,char const**,int*,int*,int*);
-  void  (*thread_cleanup)(void);
-  int  (*total_changes)(sqlite3*);
-  void * (*trace)(sqlite3*,void(*xTrace)(void*,const char*),void*);
-  int  (*transfer_bindings)(sqlite3_stmt*,sqlite3_stmt*);
-  void * (*update_hook)(sqlite3*,void(*)(void*,int ,char const*,char const*,
-                                         sqlite_int64),void*);
-  void * (*user_data)(sqlite3_context*);
-  const void * (*value_blob)(sqlite3_value*);
-  int  (*value_bytes)(sqlite3_value*);
-  int  (*value_bytes16)(sqlite3_value*);
-  double  (*value_double)(sqlite3_value*);
-  int  (*value_int)(sqlite3_value*);
-  sqlite_int64  (*value_int64)(sqlite3_value*);
-  int  (*value_numeric_type)(sqlite3_value*);
-  const unsigned char * (*value_text)(sqlite3_value*);
-  const void * (*value_text16)(sqlite3_value*);
-  const void * (*value_text16be)(sqlite3_value*);
-  const void * (*value_text16le)(sqlite3_value*);
-  int  (*value_type)(sqlite3_value*);
-  char *(*vmprintf)(const char*,va_list);
-  /* Added ??? */
-  int (*overload_function)(sqlite3*, const char *zFuncName, int nArg);
-  /* Added by 3.3.13 */
-  int (*prepare_v2)(sqlite3*,const char*,int,sqlite3_stmt**,const char**);
-  int (*prepare16_v2)(sqlite3*,const void*,int,sqlite3_stmt**,const void**);
-  int (*clear_bindings)(sqlite3_stmt*);
-  /* Added by 3.4.1 */
-  int (*create_module_v2)(sqlite3*,const char*,const sqlite3_module*,void*,
-                          void (*xDestroy)(void *));
-  /* Added by 3.5.0 */
-  int (*bind_zeroblob)(sqlite3_stmt*,int,int);
-  int (*blob_bytes)(sqlite3_blob*);
-  int (*blob_close)(sqlite3_blob*);
-  int (*blob_open)(sqlite3*,const char*,const char*,const char*,sqlite3_int64,
-                   int,sqlite3_blob**);
-  int (*blob_read)(sqlite3_blob*,void*,int,int);
-  int (*blob_write)(sqlite3_blob*,const void*,int,int);
-  int (*create_collation_v2)(sqlite3*,const char*,int,void*,
-                             int(*)(void*,int,const void*,int,const void*),
-                             void(*)(void*));
-  int (*file_control)(sqlite3*,const char*,int,void*);
-  sqlite3_int64 (*memory_highwater)(int);
-  sqlite3_int64 (*memory_used)(void);
-  sqlite3_mutex *(*mutex_alloc)(int);
-  void (*mutex_enter)(sqlite3_mutex*);
-  void (*mutex_free)(sqlite3_mutex*);
-  void (*mutex_leave)(sqlite3_mutex*);
-  int (*mutex_try)(sqlite3_mutex*);
-  int (*open_v2)(const char*,sqlite3**,int,const char*);
-  int (*release_memory)(int);
-  void (*result_error_nomem)(sqlite3_context*);
-  void (*result_error_toobig)(sqlite3_context*);
-  int (*sleep)(int);
-  void (*soft_heap_limit)(int);
-  sqlite3_vfs *(*vfs_find)(const char*);
-  int (*vfs_register)(sqlite3_vfs*,int);
-  int (*vfs_unregister)(sqlite3_vfs*);
-  int (*xthreadsafe)(void);
-  void (*result_zeroblob)(sqlite3_context*,int);
-  void (*result_error_code)(sqlite3_context*,int);
-  int (*test_control)(int, ...);
-  void (*randomness)(int,void*);
-  sqlite3 *(*context_db_handle)(sqlite3_context*);
-  int (*extended_result_codes)(sqlite3*,int);
-  int (*limit)(sqlite3*,int,int);
-  sqlite3_stmt *(*next_stmt)(sqlite3*,sqlite3_stmt*);
-  const char *(*sql)(sqlite3_stmt*);
-  int (*status)(int,int*,int*,int);
-  int (*backup_finish)(sqlite3_backup*);
-  sqlite3_backup *(*backup_init)(sqlite3*,const char*,sqlite3*,const char*);
-  int (*backup_pagecount)(sqlite3_backup*);
-  int (*backup_remaining)(sqlite3_backup*);
-  int (*backup_step)(sqlite3_backup*,int);
-  const char *(*compileoption_get)(int);
-  int (*compileoption_used)(const char*);
-  int (*create_function_v2)(sqlite3*,const char*,int,int,void*,
-                            void (*xFunc)(sqlite3_context*,int,sqlite3_value**),
-                            void (*xStep)(sqlite3_context*,int,sqlite3_value**),
-                            void (*xFinal)(sqlite3_context*),
-                            void(*xDestroy)(void*));
-  int (*db_config)(sqlite3*,int,...);
-  sqlite3_mutex *(*db_mutex)(sqlite3*);
-  int (*db_status)(sqlite3*,int,int*,int*,int);
-  int (*extended_errcode)(sqlite3*);
-  void (*log)(int,const char*,...);
-  sqlite3_int64 (*soft_heap_limit64)(sqlite3_int64);
-  const char *(*sourceid)(void);
-  int (*stmt_status)(sqlite3_stmt*,int,int);
-  int (*strnicmp)(const char*,const char*,int);
-  int (*unlock_notify)(sqlite3*,void(*)(void**,int),void*);
-  int (*wal_autocheckpoint)(sqlite3*,int);
-  int (*wal_checkpoint)(sqlite3*,const char*);
-  void *(*wal_hook)(sqlite3*,int(*)(void*,sqlite3*,const char*,int),void*);
-  int (*blob_reopen)(sqlite3_blob*,sqlite3_int64);
-  int (*vtab_config)(sqlite3*,int op,...);
-  int (*vtab_on_conflict)(sqlite3*);
-};
-
-/*
-** The following macros redefine the API routines so that they are
-** redirected throught the global sqlite3_api structure.
-**
-** This header file is also used by the loadext.c source file
-** (part of the main SQLite library - not an extension) so that
-** it can get access to the sqlite3_api_routines structure
-** definition.  But the main library does not want to redefine
-** the API.  So the redefinition macros are only valid if the
-** SQLITE_CORE macros is undefined.
-*/
-#ifndef SQLITE_CORE
-#define sqlite3_aggregate_context      sqlite3_api->aggregate_context
-#ifndef SQLITE_OMIT_DEPRECATED
-#define sqlite3_aggregate_count        sqlite3_api->aggregate_count
-#endif
-#define sqlite3_bind_blob              sqlite3_api->bind_blob
-#define sqlite3_bind_double            sqlite3_api->bind_double
-#define sqlite3_bind_int               sqlite3_api->bind_int
-#define sqlite3_bind_int64             sqlite3_api->bind_int64
-#define sqlite3_bind_null              sqlite3_api->bind_null
-#define sqlite3_bind_parameter_count   sqlite3_api->bind_parameter_count
-#define sqlite3_bind_parameter_index   sqlite3_api->bind_parameter_index
-#define sqlite3_bind_parameter_name    sqlite3_api->bind_parameter_name
-#define sqlite3_bind_text              sqlite3_api->bind_text
-#define sqlite3_bind_text16            sqlite3_api->bind_text16
-#define sqlite3_bind_value             sqlite3_api->bind_value
-#define sqlite3_busy_handler           sqlite3_api->busy_handler
-#define sqlite3_busy_timeout           sqlite3_api->busy_timeout
-#define sqlite3_changes                sqlite3_api->changes
-#define sqlite3_close                  sqlite3_api->close
-#define sqlite3_collation_needed       sqlite3_api->collation_needed
-#define sqlite3_collation_needed16     sqlite3_api->collation_needed16
-#define sqlite3_column_blob            sqlite3_api->column_blob
-#define sqlite3_column_bytes           sqlite3_api->column_bytes
-#define sqlite3_column_bytes16         sqlite3_api->column_bytes16
-#define sqlite3_column_count           sqlite3_api->column_count
-#define sqlite3_column_database_name   sqlite3_api->column_database_name
-#define sqlite3_column_database_name16 sqlite3_api->column_database_name16
-#define sqlite3_column_decltype        sqlite3_api->column_decltype
-#define sqlite3_column_decltype16      sqlite3_api->column_decltype16
-#define sqlite3_column_double          sqlite3_api->column_double
-#define sqlite3_column_int             sqlite3_api->column_int
-#define sqlite3_column_int64           sqlite3_api->column_int64
-#define sqlite3_column_name            sqlite3_api->column_name
-#define sqlite3_column_name16          sqlite3_api->column_name16
-#define sqlite3_column_origin_name     sqlite3_api->column_origin_name
-#define sqlite3_column_origin_name16   sqlite3_api->column_origin_name16
-#define sqlite3_column_table_name      sqlite3_api->column_table_name
-#define sqlite3_column_table_name16    sqlite3_api->column_table_name16
-#define sqlite3_column_text            sqlite3_api->column_text
-#define sqlite3_column_text16          sqlite3_api->column_text16
-#define sqlite3_column_type            sqlite3_api->column_type
-#define sqlite3_column_value           sqlite3_api->column_value
-#define sqlite3_commit_hook            sqlite3_api->commit_hook
-#define sqlite3_complete               sqlite3_api->complete
-#define sqlite3_complete16             sqlite3_api->complete16
-#define sqlite3_create_collation       sqlite3_api->create_collation
-#define sqlite3_create_collation16     sqlite3_api->create_collation16
-#define sqlite3_create_function        sqlite3_api->create_function
-#define sqlite3_create_function16      sqlite3_api->create_function16
-#define sqlite3_create_module          sqlite3_api->create_module
-#define sqlite3_create_module_v2       sqlite3_api->create_module_v2
-#define sqlite3_data_count             sqlite3_api->data_count
-#define sqlite3_db_handle              sqlite3_api->db_handle
-#define sqlite3_declare_vtab           sqlite3_api->declare_vtab
-#define sqlite3_enable_shared_cache    sqlite3_api->enable_shared_cache
-#define sqlite3_errcode                sqlite3_api->errcode
-#define sqlite3_errmsg                 sqlite3_api->errmsg
-#define sqlite3_errmsg16               sqlite3_api->errmsg16
-#define sqlite3_exec                   sqlite3_api->exec
-#ifndef SQLITE_OMIT_DEPRECATED
-#define sqlite3_expired                sqlite3_api->expired
-#endif
-#define sqlite3_finalize               sqlite3_api->finalize
-#define sqlite3_free                   sqlite3_api->free
-#define sqlite3_free_table             sqlite3_api->free_table
-#define sqlite3_get_autocommit         sqlite3_api->get_autocommit
-#define sqlite3_get_auxdata            sqlite3_api->get_auxdata
-#define sqlite3_get_table              sqlite3_api->get_table
-#ifndef SQLITE_OMIT_DEPRECATED
-#define sqlite3_global_recover         sqlite3_api->global_recover
-#endif
-#define sqlite3_interrupt              sqlite3_api->interruptx
-#define sqlite3_last_insert_rowid      sqlite3_api->last_insert_rowid
-#define sqlite3_libversion             sqlite3_api->libversion
-#define sqlite3_libversion_number      sqlite3_api->libversion_number
-#define sqlite3_malloc                 sqlite3_api->malloc
-#define sqlite3_mprintf                sqlite3_api->mprintf
-#define sqlite3_open                   sqlite3_api->open
-#define sqlite3_open16                 sqlite3_api->open16
-#define sqlite3_prepare                sqlite3_api->prepare
-#define sqlite3_prepare16              sqlite3_api->prepare16
-#define sqlite3_prepare_v2             sqlite3_api->prepare_v2
-#define sqlite3_prepare16_v2           sqlite3_api->prepare16_v2
-#define sqlite3_profile                sqlite3_api->profile
-#define sqlite3_progress_handler       sqlite3_api->progress_handler
-#define sqlite3_realloc                sqlite3_api->realloc
-#define sqlite3_reset                  sqlite3_api->reset
-#define sqlite3_result_blob            sqlite3_api->result_blob
-#define sqlite3_result_double          sqlite3_api->result_double
-#define sqlite3_result_error           sqlite3_api->result_error
-#define sqlite3_result_error16         sqlite3_api->result_error16
-#define sqlite3_result_int             sqlite3_api->result_int
-#define sqlite3_result_int64           sqlite3_api->result_int64
-#define sqlite3_result_null            sqlite3_api->result_null
-#define sqlite3_result_text            sqlite3_api->result_text
-#define sqlite3_result_text16          sqlite3_api->result_text16
-#define sqlite3_result_text16be        sqlite3_api->result_text16be
-#define sqlite3_result_text16le        sqlite3_api->result_text16le
-#define sqlite3_result_value           sqlite3_api->result_value
-#define sqlite3_rollback_hook          sqlite3_api->rollback_hook
-#define sqlite3_set_authorizer         sqlite3_api->set_authorizer
-#define sqlite3_set_auxdata            sqlite3_api->set_auxdata
-#define sqlite3_snprintf               sqlite3_api->snprintf
-#define sqlite3_step                   sqlite3_api->step
-#define sqlite3_table_column_metadata  sqlite3_api->table_column_metadata
-#define sqlite3_thread_cleanup         sqlite3_api->thread_cleanup
-#define sqlite3_total_changes          sqlite3_api->total_changes
-#define sqlite3_trace                  sqlite3_api->trace
-#ifndef SQLITE_OMIT_DEPRECATED
-#define sqlite3_transfer_bindings      sqlite3_api->transfer_bindings
-#endif
-#define sqlite3_update_hook            sqlite3_api->update_hook
-#define sqlite3_user_data              sqlite3_api->user_data
-#define sqlite3_value_blob             sqlite3_api->value_blob
-#define sqlite3_value_bytes            sqlite3_api->value_bytes
-#define sqlite3_value_bytes16          sqlite3_api->value_bytes16
-#define sqlite3_value_double           sqlite3_api->value_double
-#define sqlite3_value_int              sqlite3_api->value_int
-#define sqlite3_value_int64            sqlite3_api->value_int64
-#define sqlite3_value_numeric_type     sqlite3_api->value_numeric_type
-#define sqlite3_value_text             sqlite3_api->value_text
-#define sqlite3_value_text16           sqlite3_api->value_text16
-#define sqlite3_value_text16be         sqlite3_api->value_text16be
-#define sqlite3_value_text16le         sqlite3_api->value_text16le
-#define sqlite3_value_type             sqlite3_api->value_type
-#define sqlite3_vmprintf               sqlite3_api->vmprintf
-#define sqlite3_overload_function      sqlite3_api->overload_function
-#define sqlite3_prepare_v2             sqlite3_api->prepare_v2
-#define sqlite3_prepare16_v2           sqlite3_api->prepare16_v2
-#define sqlite3_clear_bindings         sqlite3_api->clear_bindings
-#define sqlite3_bind_zeroblob          sqlite3_api->bind_zeroblob
-#define sqlite3_blob_bytes             sqlite3_api->blob_bytes
-#define sqlite3_blob_close             sqlite3_api->blob_close
-#define sqlite3_blob_open              sqlite3_api->blob_open
-#define sqlite3_blob_read              sqlite3_api->blob_read
-#define sqlite3_blob_write             sqlite3_api->blob_write
-#define sqlite3_create_collation_v2    sqlite3_api->create_collation_v2
-#define sqlite3_file_control           sqlite3_api->file_control
-#define sqlite3_memory_highwater       sqlite3_api->memory_highwater
-#define sqlite3_memory_used            sqlite3_api->memory_used
-#define sqlite3_mutex_alloc            sqlite3_api->mutex_alloc
-#define sqlite3_mutex_enter            sqlite3_api->mutex_enter
-#define sqlite3_mutex_free             sqlite3_api->mutex_free
-#define sqlite3_mutex_leave            sqlite3_api->mutex_leave
-#define sqlite3_mutex_try              sqlite3_api->mutex_try
-#define sqlite3_open_v2                sqlite3_api->open_v2
-#define sqlite3_release_memory         sqlite3_api->release_memory
-#define sqlite3_result_error_nomem     sqlite3_api->result_error_nomem
-#define sqlite3_result_error_toobig    sqlite3_api->result_error_toobig
-#define sqlite3_sleep                  sqlite3_api->sleep
-#define sqlite3_soft_heap_limit        sqlite3_api->soft_heap_limit
-#define sqlite3_vfs_find               sqlite3_api->vfs_find
-#define sqlite3_vfs_register           sqlite3_api->vfs_register
-#define sqlite3_vfs_unregister         sqlite3_api->vfs_unregister
-#define sqlite3_threadsafe             sqlite3_api->xthreadsafe
-#define sqlite3_result_zeroblob        sqlite3_api->result_zeroblob
-#define sqlite3_result_error_code      sqlite3_api->result_error_code
-#define sqlite3_test_control           sqlite3_api->test_control
-#define sqlite3_randomness             sqlite3_api->randomness
-#define sqlite3_context_db_handle      sqlite3_api->context_db_handle
-#define sqlite3_extended_result_codes  sqlite3_api->extended_result_codes
-#define sqlite3_limit                  sqlite3_api->limit
-#define sqlite3_next_stmt              sqlite3_api->next_stmt
-#define sqlite3_sql                    sqlite3_api->sql
-#define sqlite3_status                 sqlite3_api->status
-#define sqlite3_backup_finish          sqlite3_api->backup_finish
-#define sqlite3_backup_init            sqlite3_api->backup_init
-#define sqlite3_backup_pagecount       sqlite3_api->backup_pagecount
-#define sqlite3_backup_remaining       sqlite3_api->backup_remaining
-#define sqlite3_backup_step            sqlite3_api->backup_step
-#define sqlite3_compileoption_get      sqlite3_api->compileoption_get
-#define sqlite3_compileoption_used     sqlite3_api->compileoption_used
-#define sqlite3_create_function_v2     sqlite3_api->create_function_v2
-#define sqlite3_db_config              sqlite3_api->db_config
-#define sqlite3_db_mutex               sqlite3_api->db_mutex
-#define sqlite3_db_status              sqlite3_api->db_status
-#define sqlite3_extended_errcode       sqlite3_api->extended_errcode
-#define sqlite3_log                    sqlite3_api->log
-#define sqlite3_soft_heap_limit64      sqlite3_api->soft_heap_limit64
-#define sqlite3_sourceid               sqlite3_api->sourceid
-#define sqlite3_stmt_status            sqlite3_api->stmt_status
-#define sqlite3_strnicmp               sqlite3_api->strnicmp
-#define sqlite3_unlock_notify          sqlite3_api->unlock_notify
-#define sqlite3_wal_autocheckpoint     sqlite3_api->wal_autocheckpoint
-#define sqlite3_wal_checkpoint         sqlite3_api->wal_checkpoint
-#define sqlite3_wal_hook               sqlite3_api->wal_hook
-#define sqlite3_blob_reopen            sqlite3_api->blob_reopen
-#define sqlite3_vtab_config            sqlite3_api->vtab_config
-#define sqlite3_vtab_on_conflict       sqlite3_api->vtab_on_conflict
-#endif /* SQLITE_CORE */
-
-#define SQLITE_EXTENSION_INIT1     const sqlite3_api_routines *sqlite3_api = 0;
-#define SQLITE_EXTENSION_INIT2(v)  sqlite3_api = v;
-
-#endif /* _SQLITE3EXT_H_ */

utils/convolvetest/Makefile

@@ -0,0 +1,18 @@
+all: main.o convolve_base.o convolve.o convolve_sse_3.o
+	gcc -g -Wall ./*.o -o convtest -losmocore
+
+clean:
+	rm -f ./*.o
+	rm -f ./convtest
+
+main.o: main.c
+	gcc -g -Wall -c main.c
+
+convolve_base.o: ../../Transceiver52M/common/convolve_base.c
+	gcc -std=c99 -c ../../Transceiver52M/common/convolve_base.c
+
+convolve.o: ../../Transceiver52M/x86/convolve.c
+	gcc -std=c99 -c ../../Transceiver52M/x86/convolve.c -I ../../Transceiver52M/common/ -msse3 -DHAVE_SSE3
+
+convolve_sse_3.o: ../../Transceiver52M/x86/convolve_sse_3.c
+	gcc -std=c99 -c ../../Transceiver52M/x86/convolve_sse_3.c -I ../../Transceiver52M/common/ -msse3 -DHAVE_SSE3

utils/convolvetest/convtest.ok

@@ -0,0 +1,72 @@
+==== TEST COMPLEX BASE IMPLEMENTATION ====
+float x[] = {0.828957,0.675654,0.904170,0.191112,0.394521,0.706067,0.868924,0.547397,0.738959,0.932485,0.233119,0.926576,0.551443,0.933420,0.494407,0.552568,0.939129,0.799646,0.814139,0.594497,0.657201,0.995300,0.935852,0.324541,0.874309,0.589157,0.637771,0.759324,0.775421,0.794910,0.262785,0.604379,0.470564,0.166955}
+
+float h[] = {0.726144,0.746635,0.470674,0.211604,0.963092,0.264553,0.265818,0.725771,0.590649,0.313560,0.547613,0.946811,0.793753,0.690502,0.276120,0.792995,0.446645}
+
+float y[] = {0.389293,10.824917,-0.676577,10.619646,0.283489,11.279525,0.384482,11.586230,0.711259,11.540458,-0.391531,11.281723,0.019900,12.278080,-0.070459,11.104558,0.087938,11.825965,-1.003252,11.698885,0.358887,11.911197,-0.678904,11.933812,0.245140,11.886644}
+
+==== TEST COMPLEX SSE3 IMPLEMENTATION: (h_len%4=0) ====
+float x[] = {0.828957,0.675654,0.904170,0.191112,0.394521,0.706067,0.868924,0.547397,0.738959,0.932485,0.233119,0.926576,0.551443,0.933420,0.494407,0.552568,0.939129,0.799646,0.814139,0.594497,0.657201,0.995300,0.935852,0.324541,0.874309,0.589157,0.637771,0.759324,0.775421,0.794910,0.262785,0.604379,0.470564,0.166955}
+
+float h[] = {0.726144,0.746635,0.470674,0.211604,0.963092,0.264553,0.265818,0.725771,0.590649,0.313560,0.547613,0.946811,0.793753,0.690502,0.276120,0.792995,0.446645,0.327805,0.785346,0.676628}
+
+float y[] = {-0.641594,12.367426,-0.970113,12.963129,-0.466783,13.747334,0.637486,13.341836,-0.168561,14.091346,0.306652,15.018833,0.233741,14.726789,-0.011241,15.034849,0.000155,13.639509,0.558827,15.495646,-0.406179,14.103148,-0.000244,15.591370,-0.492319,14.785577}
+
+==== TEST COMPLEX SSE3 IMPLEMENTATION: (h_len%8=0) ====
+float x[] = {0.828957,0.675654,0.904170,0.191112,0.394521,0.706067,0.868924,0.547397,0.738959,0.932485,0.233119,0.926576,0.551443,0.933420,0.494407,0.552568,0.939129,0.799646,0.814139,0.594497,0.657201,0.995300,0.935852,0.324541,0.874309,0.589157,0.637771,0.759324,0.775421,0.794910,0.262785,0.604379,0.470564,0.166955}
+
+float h[] = {0.726144,0.746635,0.470674,0.211604,0.963092,0.264553,0.265818,0.725771,0.590649,0.313560,0.547613,0.946811,0.793753,0.690502,0.276120,0.792995}
+
+float y[] = {-0.278295,10.097409,0.919633,11.502825,0.340383,10.979163,0.891132,11.679869,0.425363,11.186544,1.099703,12.121126,0.188196,11.180099,0.228905,12.436676,0.149904,11.522589,0.543155,11.703615,0.033465,12.425473,0.561782,12.373415,-0.218184,12.154579}
+
+
+
+==== TEST REAL BASE IMPLEMENTATION ====
+float x[] = {0.828957,0.675654,0.904170,0.191112,0.394521,0.706067,0.868924,0.547397,0.738959,0.932485,0.233119,0.926576,0.551443,0.933420,0.494407,0.552568,0.939129,0.799646,0.814139,0.594497,0.657201,0.995300,0.935852,0.324541,0.874309,0.589157,0.637771,0.759324,0.775421,0.794910,0.262785,0.604379,0.470564,0.166955}
+
+float h[] = {0.726144,0.746635,0.470674,0.211604,0.963092,0.264553,0.265818,0.725771,0.590649,0.313560,0.547613,0.946811,0.793753,0.690502,0.276120,0.792995,0.446645}
+
+float y[] = {5.354852,5.387001,4.829278,5.046340,5.849788,5.775999,5.653334,5.372714,5.999860,5.593828,5.628739,5.178002,6.010774,6.186034,6.337766,5.538046,5.616131,6.289612,5.486091,5.835261,6.277413,5.894117,5.563587,6.082063,5.828556,6.160175}
+
+==== TEST REAL SSE3 IMPLEMENTATION (hlen=4) ====
+float x[] = {0.828957,0.675654,0.904170,0.191112,0.394521,0.706067,0.868924,0.547397,0.738959,0.932485,0.233119,0.926576,0.551443,0.933420,0.494407,0.552568,0.939129,0.799646,0.814139,0.594497,0.657201,0.995300,0.935852,0.324541,0.874309,0.589157,0.637771,0.759324,0.775421,0.794910,0.262785,0.604379,0.470564,0.166955}
+
+float h[] = {0.726144,0.746635,0.470674,0.211604}
+
+float y[] = {1.154625,1.856899,1.754012,1.866038,1.759821,1.614741,1.946849,1.905307,2.034228,1.369325,1.929276,1.644739,1.911431,1.455565,1.751712,1.711433,1.206255,1.551974,1.351406,1.252433,1.410497,1.527218,1.666560,1.330974,1.544475,1.701906}
+
+==== TEST REAL SSE3 IMPLEMENTATION (hlen=8) ====
+float x[] = {0.828957,0.675654,0.904170,0.191112,0.394521,0.706067,0.868924,0.547397,0.738959,0.932485,0.233119,0.926576,0.551443,0.933420,0.494407,0.552568,0.939129,0.799646,0.814139,0.594497,0.657201,0.995300,0.935852,0.324541,0.874309,0.589157,0.637771,0.759324,0.775421,0.794910,0.262785,0.604379,0.470564,0.166955}
+
+float h[] = {0.726144,0.746635,0.470674,0.211604,0.963092,0.264553,0.265818,0.725771}
+
+float y[] = {2.966950,2.964003,3.035802,3.567513,2.983864,3.487861,3.089418,3.836586,2.979637,3.173361,3.524760,3.308944,3.511707,2.951268,3.500564,3.466951,3.174077,2.778949,3.124344,2.816606,3.196814,2.774090,3.272130,2.980138,2.646414,3.090803}
+
+==== TEST REAL SSE3 IMPLEMENTATION (hlen=12) ====
+float x[] = {0.828957,0.675654,0.904170,0.191112,0.394521,0.706067,0.868924,0.547397,0.738959,0.932485,0.233119,0.926576,0.551443,0.933420,0.494407,0.552568,0.939129,0.799646,0.814139,0.594497,0.657201,0.995300,0.935852,0.324541,0.874309,0.589157,0.637771,0.759324,0.775421,0.794910,0.262785,0.604379,0.470564,0.166955}
+
+float h[] = {0.726144,0.746635,0.470674,0.211604,0.963092,0.264553,0.265818,0.725771,0.590649,0.313560,0.547613,0.946811}
+
+float y[] = {3.906606,3.831477,4.613783,4.371631,4.441847,4.311853,4.446086,5.089131,4.708794,4.314635,4.866886,4.812932,4.678810,4.796319,4.687846,5.426141,4.119072,4.687284,4.516533,4.303559,4.733458,4.146965,5.133350,4.832816,4.598291,4.252030}
+
+==== TEST REAL SSE3 IMPLEMENTATION (hlen=16) ====
+float x[] = {0.828957,0.675654,0.904170,0.191112,0.394521,0.706067,0.868924,0.547397,0.738959,0.932485,0.233119,0.926576,0.551443,0.933420,0.494407,0.552568,0.939129,0.799646,0.814139,0.594497,0.657201,0.995300,0.935852,0.324541,0.874309,0.589157,0.637771,0.759324,0.775421,0.794910,0.262785,0.604379,0.470564,0.166955}
+
+float h[] = {0.726144,0.746635,0.470674,0.211604,0.963092,0.264553,0.265818,0.725771,0.590649,0.313560,0.547613,0.946811,0.793753,0.690502,0.276120,0.792995}
+
+float y[] = {4.845784,5.086479,6.160082,6.147918,5.549072,5.538811,6.264142,6.083664,5.942431,5.214122,6.458036,6.120992,6.385656,5.751343,6.099504,6.738166,5.942206,5.756058,6.343914,6.239408,6.090616,6.325348,6.214744,6.674619,5.691174,6.413076}
+
+==== TEST REAL SSE3 IMPLEMENTATION (hlen=20) ====
+float x[] = {0.828957,0.675654,0.904170,0.191112,0.394521,0.706067,0.868924,0.547397,0.738959,0.932485,0.233119,0.926576,0.551443,0.933420,0.494407,0.552568,0.939129,0.799646,0.814139,0.594497,0.657201,0.995300,0.935852,0.324541,0.874309,0.589157,0.637771,0.759324,0.775421,0.794910,0.262785,0.604379,0.470564,0.166955}
+
+float h[] = {0.726144,0.746635,0.470674,0.211604,0.963092,0.264553,0.265818,0.725771,0.590649,0.313560,0.547613,0.946811,0.793753,0.690502,0.276120,0.792995,0.446645,0.327805,0.785346,0.676628}
+
+float y[] = {6.148925,6.262301,5.792440,6.652380,6.759685,6.515733,6.943458,6.334218,6.539823,6.542612,7.766725,7.472028,7.258010,6.947061,7.347066,7.503224,7.134092,6.244353,7.690946,7.584768,7.779833,6.845586,7.351567,8.099596,7.393943,7.176465}
+
+==== TEST REAL SSE3 IMPLEMENTATION (h_len%4=0) ====
+float x[] = {0.828957,0.675654,0.904170,0.191112,0.394521,0.706067,0.868924,0.547397,0.738959,0.932485,0.233119,0.926576,0.551443,0.933420,0.494407,0.552568,0.939129,0.799646,0.814139,0.594497,0.657201,0.995300,0.935852,0.324541,0.874309,0.589157,0.637771,0.759324,0.775421,0.794910,0.262785,0.604379,0.470564,0.166955}
+
+float h[] = {0.726144,0.746635,0.470674,0.211604,0.963092,0.264553,0.265818,0.725771,0.590649,0.313560,0.547613,0.946811,0.793753,0.690502,0.276120,0.792995,0.446645,0.327805,0.785346,0.676628,0.906507,0.279178,0.015699,0.609179}
+
+float y[] = {7.032490,7.904466,6.745667,7.146502,6.958916,7.972230,7.314566,6.972099,7.773273,7.740826,7.380684,7.907260,8.446323,7.862378,8.022881,7.726059,7.748359,7.602177,8.926439,8.905205,8.569546,7.948394,8.588051,8.850824,8.592319,7.636216}
+

utils/convolvetest/main.c

@@ -0,0 +1,150 @@
+#include <stdio.h>
+#include <string.h>
+#include <osmocom/core/utils.h>
+#include "../../Transceiver52M/common/convolve.h"
+
+#define TESTVEC_LEN 1000
+#define DO_INIT 1
+
+float x_vect[TESTVEC_LEN];
+float y_vect[TESTVEC_LEN];
+float h_vect[TESTVEC_LEN];
+
+float *x;
+float *h;
+float *y;
+
+/* Generate some random values for testing */
+void gen_floats(float *vect, int len)
+{
+	int i;
+	for(i=0;i<len;i++) {
+		vect[i] = (float)rand()/(float)(RAND_MAX);
+	}
+}
+
+/* Reset testvectors */
+static void reset_testvec(int seed)
+{
+	srand(seed);
+	memset(x_vect,0,sizeof(x_vect));
+	memset(y_vect,0,sizeof(y_vect));
+	memset(h_vect,0,sizeof(h_vect));
+
+	x=x_vect + TESTVEC_LEN/2;
+	y=y_vect + TESTVEC_LEN/2;
+	h=h_vect + TESTVEC_LEN/2;
+
+	gen_floats(x_vect,TESTVEC_LEN);
+	gen_floats(h_vect,TESTVEC_LEN);
+}
+
+/* Show float vector data cut and paste friendly */
+static void dump_floats(float *vect, int len, char *name)
+{
+	int i;
+
+	printf("float %s[] = {", name);
+	for(i=0;i<len;i++) {
+
+		printf("%f",vect[i]);
+
+		if(i<len-1)
+			printf(",");
+	}
+	printf("}\n");
+}
+
+/* Test complex convolution */
+static void test_convolve_complex(int h_len)
+{
+	int x_len;
+	int y_len;
+	int start;
+	int len;
+	int step;
+	int offset;
+
+	x_len=34;
+	y_len=26;
+	start=8;
+	len=26;
+	step=1;
+	offset=1;
+	reset_testvec(0);
+	dump_floats(x,x_len,"x");
+	printf("\n");
+	dump_floats(h,h_len,"h");
+	printf("\n");
+	convolve_complex(x, x_len, h, h_len, y, y_len, start, len, step, offset);
+	dump_floats(y,y_len,"y");
+	printf("\n");
+}
+
+/* Test real convolution */
+static void test_convolve_real(int h_len)
+{
+	int x_len;
+	int y_len;
+	int start;
+	int len;
+	int step;
+	int offset;
+
+	x_len=34;
+	y_len=26;
+	start=8;
+	len=26;
+	step=1;
+	offset=1;
+	reset_testvec(0);
+	dump_floats(x,x_len,"x");
+	printf("\n");
+	dump_floats(h,h_len,"h");
+	printf("\n");
+	convolve_real(x, x_len, h, h_len, y, y_len, start, len, step, offset);
+	dump_floats(y,y_len,"y");
+	printf("\n");
+}
+
+int main(void)
+{
+#if DO_INIT == 1
+	convolve_init();
+#endif
+
+	printf("==== TEST COMPLEX BASE IMPLEMENTATION ====\n");
+	test_convolve_complex(17);
+
+	printf("==== TEST COMPLEX SSE3 IMPLEMENTATION: (h_len%%4=0) ====\n");
+	test_convolve_complex(20);
+
+	printf("==== TEST COMPLEX SSE3 IMPLEMENTATION: (h_len%%8=0) ====\n");
+	test_convolve_complex(16);
+
+	printf("\n");
+	printf("\n");
+
+	printf("==== TEST REAL BASE IMPLEMENTATION ====\n");
+	test_convolve_real(17);
+
+	printf("==== TEST REAL SSE3 IMPLEMENTATION (hlen=4) ====\n");
+	test_convolve_real(4);
+
+	printf("==== TEST REAL SSE3 IMPLEMENTATION (hlen=8) ====\n");
+	test_convolve_real(8);
+
+	printf("==== TEST REAL SSE3 IMPLEMENTATION (hlen=12) ====\n");
+	test_convolve_real(12);
+
+	printf("==== TEST REAL SSE3 IMPLEMENTATION (hlen=16) ====\n");
+	test_convolve_real(16);
+
+	printf("==== TEST REAL SSE3 IMPLEMENTATION (hlen=20) ====\n");
+	test_convolve_real(20);
+
+	printf("==== TEST REAL SSE3 IMPLEMENTATION (h_len%%4=0) ====\n");
+	test_convolve_real(24);
+
+	return 0;
+}