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

@@ -35,7 +35,7 @@
 #ifdef DEBUG_CONFIG
 #define	debugLogEarly gLogEarly
 #else
-#define	debugLogEarly
+#define	debugLogEarly(x,y,z)
 #endif
 
 
@@ -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"
@@ -38,6 +39,14 @@
 
 using namespace std;
 
+// Switches to enable/disable logging targets
+// MUST BE DEFINED BEFORE gConfig FOR gLogEarly() TO WORK CORRECTLY
+bool gLogToConsole = true;
+bool gLogToSyslog = false;
+FILE *gLogToFile = NULL;
+Mutex gLogToLock;
+
+
 // Reference to a global config table, used all over the system.
 extern ConfigurationTable gConfig;
 
@@ -67,9 +76,6 @@ const char *levelNames[] = {
 	"EMERG", "ALERT", "CRIT", "ERR", "WARNING", "NOTICE", "INFO", "DEBUG"
 };
 int numLevels = 8;
-bool gLogToConsole = 0;
-FILE *gLogToFile = NULL;
-Mutex gLogToLock;
 
 
 int levelStringToInt(const string& name)
@@ -106,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)
 {
@@ -192,18 +223,20 @@ Log::~Log()
 	if (mDummyInit) return;
 	// Anything at or above LOG_CRIT is an "alarm".
 	// Save alarms in the local list and echo them to stderr.
-	if (mPriority <= LOG_CRIT) {
+	if (mPriority <= LOG_ERR) {
 		if (sLoggerInited) addAlarm(mStream.str().c_str());
 		cerr << mStream.str() << endl;
 	}
-	// Current logging level was already checked by the macro.
-	// So just log.
-	syslog(mPriority, "%s", mStream.str().c_str());
-	// pat added for easy debugging.
+	// Current logging level was already checked by the macro. So just log.
+	// Log to syslog
+	if (gLogToSyslog) {
+		syslog(mPriority, "%s", mStream.str().c_str());
+	}
+	// Log to file and console
 	if (gLogToConsole||gLogToFile) {
 		int mlen = mStream.str().size();
 		int neednl = (mlen==0 || mStream.str()[mlen-1] != '\n');
-		gLogToLock.lock();
+		ScopedLock lock(gLogToLock);
 		if (gLogToConsole) {
 			// The COUT() macro prevents messages from stomping each other but adds uninteresting thread numbers,
 			// so just use std::cout.
@@ -215,7 +248,6 @@ Log::~Log()
 			if (neednl) {fputc('\n',gLogToFile);}
 			fflush(gLogToFile);
 		}
-		gLogToLock.unlock();
 	}
 }
 
@@ -243,10 +275,9 @@ void gLogInit(const char* name, const char* level, int facility)
 		gConfig.set("Log.Level",level);
 	}
 
-	// Pat added, tired of the syslog facility.
 	// Both the transceiver and OpenBTS use this same facility, but only OpenBTS/OpenNodeB may use this log file:
 	string str = gConfig.getStr("Log.File");
-	if (gLogToFile==0 && str.length() && 0==strncmp(gCmdName,"Open",4)) {
+	if (gLogToFile==NULL && str.length() && 0==strncmp(gCmdName,"Open",4)) {
 		const char *fn = str.c_str();
 		if (fn && *fn && strlen(fn)>3) {	// strlen because a garbage char is getting in sometimes.
 			gLogToFile = fopen(fn,"w"); // New log file each time we start.
@@ -268,9 +299,32 @@ void gLogInit(const char* name, const char* level, int facility)
 void gLogEarly(int level, const char *fmt, ...)
 {
 	va_list args;
- 
+
 	va_start(args, fmt);
-	vsyslog(level | LOG_USER, fmt, args);
+
+	if (gLogToSyslog) {
+		va_list args_copy;
+		va_copy(args_copy, args);
+		vsyslog(level | LOG_USER, fmt, args_copy);
+		va_end(args_copy);
+	}
+
+	if (gLogToConsole) {
+		va_list args_copy;
+		va_copy(args_copy, args);
+		vprintf(fmt, args_copy);
+		printf("\n");
+		va_end(args_copy);
+	}
+
+	if (gLogToFile) {
+		va_list args_copy;
+		va_copy(args_copy, args);
+		vfprintf(gLogToFile, fmt, args_copy);
+		fprintf(gLogToFile, "\n");
+		va_end(args_copy);
+	}
+
 	va_end(args);
 }
 

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.
@@ -116,12 +115,15 @@ class Log {
 
 	std::ostringstream& get();
 };
-extern bool gLogToConsole;	// Pat added for easy debugging.
+extern bool gLogToConsole;	// Output log messages to stdout
+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/Sockets.cpp

@@ -187,24 +187,20 @@ int DatagramSocket::send(const struct sockaddr* dest, const char * message)
 	return send(dest,message,length);
 }
 
-
-
-
-
-int DatagramSocket::read(char* buffer)
+int DatagramSocket::read(char* buffer, size_t length)
 {
-	socklen_t temp_len = sizeof(mSource);
-	int length = recvfrom(mSocketFD, (void*)buffer, MAX_UDP_LENGTH, 0,
-	    (struct sockaddr*)&mSource,&temp_len);
-	if ((length==-1) && (errno!=EAGAIN)) {
+	socklen_t addr_len = sizeof(mSource);
+	int rd_length = recvfrom(mSocketFD, (void *) buffer, length, 0,
+		(struct sockaddr*) &mSource, &addr_len);
+
+	if ((rd_length==-1) && (errno!=EAGAIN)) {
 		perror("DatagramSocket::read() failed");
 		throw SocketError();
 	}
-	return length;
+	return rd_length;
 }
 
-
-int DatagramSocket::read(char* buffer, unsigned timeout)
+int DatagramSocket::read(char* buffer, size_t length, unsigned timeout)
 {
 	fd_set fds;
 	FD_ZERO(&fds);
@@ -218,7 +214,7 @@ int DatagramSocket::read(char* buffer, unsigned timeout)
 		throw SocketError();
 	}
 	if (sel==0) return -1;
-	if (FD_ISSET(mSocketFD,&fds)) return read(buffer);
+	if (FD_ISSET(mSocketFD,&fds)) return read(buffer, length);
 	return -1;
 }
 
@@ -269,7 +265,7 @@ void UDPSocket::open(unsigned short localPort)
 	size_t length = sizeof(address);
 	bzero(&address,length);
 	address.sin_family = AF_INET;
-	address.sin_addr.s_addr = INADDR_ANY;
+	address.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
 	address.sin_port = htons(localPort);
 	if (bind(mSocketFD,(struct sockaddr*)&address,length)<0) {
 		perror("bind() failed");

CommonLibs/Sockets.h

@@ -108,7 +108,7 @@ public:
 		@param buffer A char[MAX_UDP_LENGTH] procured by the caller.
 		@return The number of bytes received or -1 on non-blocking pass.
 	*/
-	int read(char* buffer);
+	int read(char* buffer, size_t length);
 
 	/**
 		Receive a packet with a timeout.
@@ -116,7 +116,7 @@ public:
 		@param maximum wait time in milliseconds
 		@return The number of bytes received or -1 on timeout.
 	*/
-	int read(char* buffer, unsigned timeout);
+	int read(char* buffer, size_t length, unsigned timeout);
 
 
 	/** Send a packet to a given destination, other than the default. */

CommonLibs/SocketsTest.cpp

@@ -42,7 +42,7 @@ void *testReaderIP(void *)
 	int rc = 0;
 	while (rc<gNumToSend) {
 		char buf[MAX_UDP_LENGTH];
-		int count = readSocket.read(buf);
+		int count = readSocket.read(buf, MAX_UDP_LENGTH);
 		if (count>0) {
 			COUT("read: " << buf);
 			rc++;
@@ -62,7 +62,7 @@ void *testReaderUnix(void *)
 	int rc = 0;
 	while (rc<gNumToSend) {
 		char buf[MAX_UDP_LENGTH];
-		int count = readSocket.read(buf);
+		int count = readSocket.read(buf, MAX_UDP_LENGTH);
 		if (count>0) {
 			COUT("read: " << buf);
 			rc++;

CommonLibs/Threads.h

@@ -172,8 +172,15 @@ class Thread {
 	void start(void *(*task)(void*), void *arg);
 
 	/** Join a thread that will stop on its own. */
-	void join() { int s = pthread_join(mThread,NULL); assert(!s); mThread = 0; }
+	void join() {
+		if (mThread) {
+			int s = pthread_join(mThread, NULL);
+			assert(!s);
+		}
+	}
 
+	/** Send cancelation to thread */
+	void cancel() { pthread_cancel(mThread); }
 };
 
 

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>

GSM/GSMCommon.cpp

@@ -41,11 +41,23 @@ const BitVector GSM::gTrainingSequence[] = {
     BitVector("11101111000100101110111100"),
 };
 
+const BitVector GSM::gEdgeTrainingSequence[] = {
+    BitVector("111111001111111001111001001001111111111111001111111111001111111001111001001001"),
+    BitVector("111111001111001001111001001001111001001001001111111111001111001001111001001001"),
+    BitVector("111001111111111111001001001111001001001111001111111001111111111111001001001111"),
+    BitVector("111001111111111001001001001111001001111001111111111001111111111001001001001111"),
+    BitVector("111111111001001111001111001001001111111001111111111111111001001111001111001001"),
+    BitVector("111001111111001001001111001111001001111111111111111001111111001001001111001111"),
+    BitVector("001111001111111001001001001001111001001111111111001111001111111001001001001001"),
+    BitVector("001001001111001001001001111111111001111111001111001001001111001001001001111111"),
+};
+
 const BitVector GSM::gDummyBurst("0001111101101110110000010100100111000001001000100000001111100011100010111000101110001010111010010100011001100111001111010011111000100101111101010000");
 
 const BitVector GSM::gRACHSynchSequence("01001011011111111001100110101010001111000");
 
-const BitVector GSM::gSCHSynchSequence("1011100101100010000001000000111100101101010001010111011000011011");
+//                               |-head-||---------midamble----------------------||--------------data----------------||t|
+const BitVector GSM::gRACHBurst("0011101001001011011111111001100110101010001111000110111101111110000111001001010110011000");
 
 
 int32_t GSM::FNDelta(int32_t v1, int32_t v2)

GSM/GSMCommon.h

@@ -46,15 +46,16 @@ namespace GSM {
 
 /** GSM Training sequences from GSM 05.02 5.2.3. */
 extern const BitVector gTrainingSequence[];
+extern const BitVector gEdgeTrainingSequence[];
 
 /** C0T0 filler burst, GSM 05.02, 5.2.6 */
 extern const BitVector gDummyBurst;
 
 /** Random access burst synch. sequence */
 extern const BitVector gRACHSynchSequence;
+/** Random access burst synch. sequence, GSM 05.02 5.2.7 */
+extern const BitVector gRACHBurst;
 
-/** Synchronization burst sync sequence */
-extern const BitVector gSCHSynchSequence;
 
 /**@name Modulus operations for frame numbers. */
 //@{

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 = *~

README

@@ -1,168 +1,116 @@
-Welcome to the OpenBTS source code.
+This is the interface to the transcevier.
 
-
-For free support, please subscribe to openbts-discuss@lists.sourceforge.net.
-See http://sourceforge.net/mailarchive/forum.php?forum_name=openbts-discuss
-and https://lists.sourceforge.net/lists/listinfo/openbts-discuss for details.
-
-For additional information, refer to http://openbts.org.
-
-
-These are the directories:
-
-AsteriskConfig	Asterisk configuration files for use with OpenBTS.
-CommonLib	Common-use libraries, mostly C++ wrappers for basic facilities.
-Control		Control-layer functions for the protocols of GSM 04.08 and SIP.
-GSM		The GSM stack.
-SIP		Components of the SIP state machines ued by the control layer.
-SMS		The SMS stack.
-SR		The subscriber registry.
-TRXManager	The interface between the GSM stack and the radio.
-Transceiver	The software transceiver and specific installation tests.
-apps		OpenBTS application binaries.
-doc		Project documentation.
-tests		Test fixtures for subsets of OpenBTS components.
-smqueue		RFC-3428 store-and-forward server for SMS
+Each TRX Manager UDP socket interface represents a single ARFCN.
+Each of these per-ARFCN interfaces is a pair of UDP sockets, one for control and one for data.
+Give a base port B (5700), the master clock interface is at port P=B.
+The TRX-side control interface for C(N) is on  port P=B+2N+1 and the data interface is on an odd numbered port P=B+2N+2.
+The corresponding core-side interface for every socket is at P+100.
+For any given build, the number of ARFCN interfaces can be fixed.
 
 
 
-By default, OpenBTS assumes the following UDP port assignments:
+Indications on the Master Clock Interface
 
-5060 -- Asterisk SIP interface
-5061 -- local SIP softphone
-5062 -- OpenBTS SIP interface
-5063 -- smqueue SIP interface
-5064 -- subscriber registry SIP interface
-5700-range -- OpenBTS-transceiver interface
+The master clock interface is output only (from the radio).
+Messages are "indications".
 
-These can be controlled in the CONFIG table in /etc/OpenBTS.db.
+CLOCK gives the current value of the transceiver clock to be used by the core.
+This message is sent whenever a trasmission packet arrives that is too late or too early.  The clock value is NOT the current transceiver time.  It is a time setting the the core should use to give better packet arrival times.
+IND CLOCK <totalFrames>
 
-Standrd paths:
-/OpenBTS -- Binary installation.
-/etc/OpenBTS -- Configuration databases.
-/var/run/OpenBTS -- Real-time reporting databases.
 
-The script apps/setUpFiles.sh will create these directories and install the
-correct files in them.
+
+Commands on the Per-ARFCN Control Interface
+
+The per-ARFCN control interface uses a command-reponse protocol.
+Commands are NULL-terminated ASCII strings, one per UDP socket.
+Each command has a corresponding response.
+Every command is of the form:
+
+CMD <cmdtype> [params]
+
+The <cmdtype> is the actual command.
+Parameters are optional depending on the commands type.
+Every response is of the form:
+
+RSP <cmdtype> <status> [result]
+
+The <status> is 0 for success and a non-zero error code for failure.
+Successful responses may include results, depending on the command type.
+
+
+Power Control
+
+POWEROFF shuts off transmitter power and stops the demodulator.
+CMD POWEROFF
+RSP POWEROFF <status>
+
+POWERON starts the transmitter and starts the demodulator.  Initial power level is very low.
+This command fails if the transmitter and receiver are not yet tuned.
+This command fails if the transmit or receive frequency creates a conflict with another ARFCN that is already runnng.
+If the transceiver is already on, it response with success to this command.
+CMD POWERON
+RSP POWERON <status>
+
+SETPOWER sets output power in dB wrt full scale.
+This command fails if the transmitter and receiver are not running.
+CMD SETPOWER <dB>
+RSP SETPOWER <status> <dB>
+
+ADJPOWER adjusts power by the given dB step.  Response returns resulting power level wrt full scale.
+This command fails if the transmitter and receiver are not running.
+CMD ADJPOWER <dBStep>
+RSP ADJPOWER <status> <dBLevel>
+
+
+Tuning Control
+
+RXTUNE tunes the receiver to a given frequency in kHz.
+This command fails if the receiver is already running.
+(To re-tune you stop the radio, re-tune, and restart.)
+This command fails if the transmit or receive frequency creates a conflict with another ARFCN that is already runnng.
+CMD RXTUNE <kHz>
+RSP RXTUNE <status> <kHz>
+
+TXTUNE tunes the transmitter to a given frequency in kHz.
+This command fails if the transmitter is already running.
+(To re-tune you stop the radio, re-tune, and restart.)
+This command fails if the transmit or receive frequency creates a conflict with another ARFCN that is already runnng.
+CMD TXTUNE <kHz>
+RSP TXTUNE <status> <kHz>
+
+
+Timeslot Control
+
+SETSLOT sets the format of the uplink timeslots in the ARFCN.
+The <timeslot> indicates the timeslot of interest.
+The <chantype> indicates the type of channel that occupies the timeslot.
+A chantype of zero indicates the timeslot is off.
+CMD SETSLOT <timeslot> <chantype>
+RSP SETSLOT <status> <timeslot> <chantype>
+
+
+Messages on the per-ARFCN Data Interface
+
+Messages on the data interface carry one radio burst per UDP message.
+
+
+Received Data Burst
+
+1 byte timeslot index
+4 bytes GSM frame number, big endian
+1 byte RSSI in -dBm
+2 bytes correlator timing offset in 1/256 symbol steps, 2's-comp, big endian
+148 bytes soft symbol estimates, 0 -> definite "0", 255 -> definite "1"
+
+
+Transmit Data Burst
+
+1 byte timeslot index
+4 bytes GSM frame number, big endian
+1 byte transmit level wrt ARFCN max, -dB (attenuation)
+148 bytes output symbol values, 0 & 1
 
 
 
 
-Release history:
-
-Release	Name		SVN Reposiory	SVN Rev	Comments
-
-1.0	(none)		SF.net		??		completed L1, L2
-
-1.1	Arnaudville	GNU Radio	r10019 (trunk)
-
-1.2	Breaux Bridge	GNU Radio	r10088 (trunk)	GNU Build, very early assignment
-
-1.3	Carencro	KSP		r1 (trunk)	first post-injunction release
-
-1.4	Donaldsonville	KSP		r23 (trunk)	fixed Ubuntu build error
-
-1.5	Eunice		KSP		r39 (trunk)	fixed L2 bugs related to segmentation
-							removed incomplete SMS directory
-							moved "abort" calls into L3 subclasses
-
-1.6	New Iberia	KSP		r130 (trunk)	import of all 2.2 improvements to non-SMS release
-
-
-2.0	St. Francisville KSP		r54 (smswork)	SMS support
-							file-based configuration
-
-2.1	Grand Coteau	KSP		r70 (smswork)	DTMF support
-							fixed more Linux-related build errors
-								-lpthread
-								TLMessage constructor
-							expanded stack to prevent overflows in Linux
-							moved gSIPInterface to main app
-							fixed iterator bug in Pager
-
-2.2	Houma		KSP		r122 (smswork)	added LEGAL notice
-							removed Assert classes
-							stop paging on page response
-							fixed Pager-spin bug
-							fixed Transceiver spin bugs
-							fixed 2^32 microsecond rollover bug
-							reduced stack footprints in Transceiver
-							fixed SMS timestamps
-							check LAI before using TMSI in LUR
-							reduced memory requirement by 75%
-							removed PagerTest
-							fixed stale-transaction bug in paging handler
-							fixed USRP clock rollover bug
-							faster call connection
-							new USRPDevice design
-
-2.3	Jean Lafitte	KSP		r190? (trunk)	check for out-of-date RACH bursts
-							better TRX-GSM clock sync
-							formal logging system
-							command line interface
-							emergency call setup
-
-2.4	Kinder		KSP		r208? (trunk)	fixed BCCH neighbor list bug
-							support for neighbor lists
-							fixed support for non-local Asterisk servers
-							cleaner configuration management
-							more realtime control of BCCH parameters
-							proper rejection of Hold messages
-							fixed L3 hanging bug in MTDCheckBYE
-
-2.4.1	Kinder		KSP		r462		fixed lots of valgrind errors
-
-2.4.2	Kinder		KSP		r482		zero-length calling party number bug
-							g++ 4.4 #includes
-
-2.5	Lacassine	KSP		r551		imported Joshua Lackey patches
-							SIP fixes from Anne Kwong
-							SIP fixes from testing with SMS server
-							L3 TI handling fixes
-							SMS server support
-							GNU Radio 3.2 compatibility
-							configurable max range and LU-reject cause
-							"page" & "testcall" CLI features
-
-2.5.1	Lacassine	KSP		r595		fixed some build bugs for some Linux distros
-
-2.5.2	Lacassine	KSP		r630		fixed channel assignment bug for Nokia DCT4+ handsets
-
-2.5.3	Lacassine	KSP		r756		merged fix for transceiver startup crash
-								due to use of uninitialized variables (r646)
-							merged fix for fusb bug from trunk (r582)
-
-2.5.4	Lacassine	KSP		r812		merged fixes to build under latest Fedora and
-								to build with git GnuRadio (r814)
-
-2.6	Mamou		KSP		r886		fixed infamous fusb bug (r582)
-							fixed idle-filling table size bug
-							smoother uplink power control
-							load-limiting downlink power control
-							new "config" features (optional, static)
-							IMEI interrogation
-							fixed MOD "missing FIFO" bug
-							configurable short code features
-							fixed transceiver startup crash (r646)
-							readline support is back
-							fixed timing advance bug (r844)
-							added CLI "chans" command
-							track time-of-use in TMSI table (r844)
-							added CLI "noise" command (r844)
-							added CLI "rxpower" command (r844)
-							added CLI "unconfig" command
-
-2.7	Natchitoches	Range	rxxx			(never released publicly)
-							converted TMSITable to sqlite3 (r902)
-							sqlite3-based configuration (r???)
-							converted Logger to syslogd (r903)
-							added support for rest octets (r1022)
-							external database for transaction reporting (r1184)
-							external database for channel status reporting (r1203)
-							in-call delivery and submission of text messages (r1231)
-							RFC-2833 DMTF (r1249)
-
-2.8	Opelousas	Range	rxxx			move databases to /etc and /var
-							RRLP aiding support
-
-

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

@@ -21,7 +21,7 @@
 
 include $(top_srcdir)/Makefile.common
 
-AM_CPPFLAGS = -Wall $(STD_DEFINES_AND_INCLUDES) -I./common
+AM_CPPFLAGS = -Wall $(STD_DEFINES_AND_INCLUDES) -I${srcdir}/common
 AM_CXXFLAGS = -ldl -lpthread
 
 SUBDIRS = arm x86
@@ -54,18 +54,25 @@ COMMON_SOURCES = \
 	radioInterface.cpp \
 	radioVector.cpp \
 	radioClock.cpp \
+	radioBuffer.cpp \
 	sigProcLib.cpp \
 	signalVector.cpp \
 	Transceiver.cpp \
-	sch.c
+	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 \
@@ -73,29 +80,46 @@ 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) \
-	$(SQLITE_LA) \
-	$(LIBOSMOCORE_LIBS)
+	$(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) \
+	$(COMMON_LA) $(SQLITE_LA)
 
 if USRP1 
 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,16 +167,12 @@ 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; 
-
-	/* Insert history */
-	memcpy(&in[-2 * hist_len], history, hist_len * 2 * sizeof(float));
+		return -1;
 
 	/* Generate output from precomputed input/output paths */
 	for (size_t i = 0; i < out_len; i++) {
@@ -189,25 +185,15 @@ int Resampler::rotate(float *in, size_t in_len, float *out, size_t out_len)
 			      n, 1, 1, 0);
 	}
 
-	/* Save history */
-	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];
@@ -222,7 +208,7 @@ size_t Resampler::len()
 }
 
 Resampler::Resampler(size_t p, size_t q, size_t filt_len)
-	: in_index(NULL), out_path(NULL), partitions(NULL), history(NULL)
+	: in_index(NULL), out_path(NULL), partitions(NULL)
 {
 	this->p = p;
 	this->q = q;
@@ -233,7 +219,6 @@ Resampler::~Resampler()
 {
 	releaseFilters();
 
-	delete history;
 	delete in_index;
 	delete out_path;
 }

Transceiver52M/Resampler.h

@@ -52,7 +52,7 @@ 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 
@@ -67,7 +67,6 @@ private:
 	size_t *out_path;
 
 	float **partitions;
-	float *history;
 
 	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.h

@@ -54,7 +54,7 @@ struct TransceiverState {
   ~TransceiverState();
 
   /* Initialize a multiframe slot in the filler table */
-  void init(size_t slot, signalVector *burst, bool fill);
+  bool init(int filler, size_t sps, float scale, size_t rtsc, unsigned rach_delay);
 
   int chanType[8];
 
@@ -80,115 +80,18 @@ struct TransceiverState {
 
   /* Received noise energy levels */
   float mNoiseLev;
-  avgVector mNoises;
-  avgVector mFreqOffsets;
+  noiseVector mNoises;
 
-  /* Store pointers to previous frame */
-  radioVector *prevFrame[8];
+  /* Shadowed downlink attenuation */
+  int mPower;
 
-  /* Transceiver mode */
-  int mode;
+  /* Pseudorandom bit sequence */
+  PRBS9 mPrbs;
 };
 
 /** The Transceiver class, responsible for physical layer of basestation */
 class Transceiver {
-private:
-  int mBasePort;
-  std::string mAddr;
-  GSM::Time mTransmitLatency;     ///< latency between basestation clock and transmit deadline clock
-  GSM::Time mLatencyUpdateTime;   ///< last time latency was updated
-
-  std::vector<UDPSocket *> mDataSockets;  ///< socket for writing to/reading from GSM core
-  std::vector<UDPSocket *> mCtrlSockets;  ///< socket for writing/reading control commands from GSM core
-  UDPSocket *mClockSocket;                ///< socket for writing clock updates to GSM core
-
-  std::vector<VectorQueue> mTxPriorityQueues;   ///< priority queue of transmit bursts received from GSM core
-  std::vector<VectorFIFO *>  mReceiveFIFO;      ///< radioInterface FIFO of receive bursts
-
-  std::vector<Thread *> mRxServiceLoopThreads;  ///< thread to pull bursts into receive FIFO
-  Thread *mLowerLoopThread;                   ///< thread to pull bursts into receive FIFO
-  std::vector<Thread *> mControlServiceLoopThreads;         ///< thread to process control messages from GSM core
-  std::vector<Thread *> mTxPriorityQueueServiceLoopThreads; ///< thread to process transmit bursts from GSM core
-
-  GSM::Time mTransmitDeadlineClock;       ///< deadline for pushing bursts into transmit FIFO 
-  GSM::Time mLastClockUpdateTime;         ///< last time clock update was sent up to core
-
-  RadioInterface *mRadioInterface;	  ///< associated radioInterface object
-  double txFullScale;                     ///< full scale input to radio
-  double rxFullScale;                     ///< full scale output to radio
-
-  /** 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
-    SCH,	       ///< timeslot should contain a SCH burst
-    IDLE	       ///< timeslot is an idle (or dummy) burst
-  } CorrType;
-
-  /** modulate and add a burst to the transmit queue */
-  void addRadioVector(size_t chan, BitVector &bits,
-                      int RSSI, GSM::Time &wTime);
-
-  /** Update filler table */
-  void updateFillerTable(size_t chan, radioVector *burst);
-
-  /** Push modulated burst into transmit FIFO corresponding to a particular timestamp */
-  void pushRadioVector(GSM::Time &nowTime);
-
-  /** Pull and demodulate a burst from the receive FIFO */
-  SoftVector *pullRadioVector(GSM::Time &wTime, int &RSSI,
-                              int &timingOffset, size_t chan = 0);
-
-  /** Set modulus for specific timeslot */
-  void setModulus(size_t timeslot, size_t chan);
-
-  /** return the expected burst type for the specified timestamp */
-  CorrType expectedCorrType(GSM::Time currTime, size_t chan);
-
-  /** send messages over the clock socket */
-  void writeClockInterface(void);
-
-  /** Detect RACH bursts */
-  bool detectRACH(TransceiverState *state,
-                  signalVector &burst,
-                  complex &amp, float &toa);
-
-  bool detectSCH(TransceiverState *state,
-                  signalVector &burst,
-                  complex &amp, float &toa);
-
-  bool decodeSCH(SoftVector *burst, GSM::Time *time);
-  bool correctFCCH(TransceiverState *state, signalVector *burst);
-
-  /** Detect normal bursts */
-  bool detectTSC(TransceiverState *state,
-                 signalVector &burst,
-                 complex &amp, float &toa, GSM::Time &time);
-
-  /** Demodulat burst and output soft bits */
-  SoftVector *demodulate(TransceiverState *state,
-                         signalVector &burst, complex amp,
-                         float toa, size_t tn, bool equalize);
-
-
-  int mSPSTx;                          ///< number of samples per Tx symbol
-  int mSPSRx;                          ///< number of samples per Rx symbol
-  size_t mChans;
-
-  bool mOn;			       ///< flag to indicate that transceiver is powered on
-  double mTxFreq;                      ///< the transmit frequency
-  double mRxFreq;                      ///< the receive frequency
-  int mPower;                          ///< the transmit power in dB
-  unsigned mTSC;                       ///< the midamble sequence code
-  unsigned mMaxExpectedDelay;          ///< maximum TOA offset in GSM symbols
-  unsigned long long mRxSlotMask[8];   ///< MS - enabled multiframe slot mask
-  int mBSIC;                           ///< MS - detected BSIC
-
-  std::vector<TransceiverState> mStates;
-
 public:
-
   /** Transceiver constructor 
       @param wBasePort base port number of UDP sockets
       @param TRXAddress IP address of the TRX manager, as a string
@@ -197,17 +100,17 @@ public:
       @param radioInterface associated radioInterface object
   */
   Transceiver(int wBasePort,
-	      const char *TRXAddress,
-	      size_t wSPS, size_t chans,
-	      GSM::Time wTransmitLatency,
-	      RadioInterface *wRadioInterface);
+              const char *TRXAddress,
+              size_t tx_sps, size_t rx_sps, size_t chans,
+              GSM::Time wTransmitLatency,
+              RadioInterface *wRadioInterface,
+              double wRssiOffset);
 
   /** Destructor */
   ~Transceiver();
 
-  /** start the Transceiver */
-  void start();
-  bool init(bool filler);
+  /** Start the control loop */
+  bool init(int filler, size_t rtsc, unsigned rach_delay, bool edge);
 
   /** attach the radioInterface receive FIFO */
   bool receiveFIFO(VectorFIFO *wFIFO, size_t chan)
@@ -242,13 +145,89 @@ public:
     LOOPBACK            ///< similar go VII, used in loopback testing
   } ChannelCombination;
 
-  enum {
-    TRX_MODE_OFF,
-    TRX_MODE_BTS,
-    TRX_MODE_MS_ACQUIRE,
-    TRX_MODE_MS_TRACK,
+  enum FillerType {
+    FILLER_DUMMY,
+    FILLER_ZERO,
+    FILLER_NORM_RAND,
+    FILLER_EDGE_RAND,
+    FILLER_ACCESS_RAND,
   };
 
+private:
+  int mBasePort;
+  std::string mAddr;
+
+  std::vector<UDPSocket *> mDataSockets;  ///< socket for writing to/reading from GSM core
+  std::vector<UDPSocket *> mCtrlSockets;  ///< socket for writing/reading control commands from GSM core
+  UDPSocket mClockSocket;                 ///< socket for writing clock updates to GSM core
+
+  std::vector<VectorQueue> mTxPriorityQueues;   ///< priority queue of transmit bursts received from GSM core
+  std::vector<VectorFIFO *>  mReceiveFIFO;      ///< radioInterface FIFO of receive bursts
+
+  std::vector<Thread *> mRxServiceLoopThreads;  ///< thread to pull bursts into receive FIFO
+  Thread *mRxLowerLoopThread;                   ///< thread to pull bursts into receive FIFO
+  Thread *mTxLowerLoopThread;                   ///< thread to push bursts into transmit FIFO
+  std::vector<Thread *> mControlServiceLoopThreads;         ///< thread to process control messages from GSM core
+  std::vector<Thread *> mTxPriorityQueueServiceLoopThreads; ///< thread to process transmit bursts from GSM core
+
+  GSM::Time mTransmitLatency;             ///< latency between basestation clock and transmit deadline clock
+  GSM::Time mLatencyUpdateTime;           ///< last time latency was updated
+  GSM::Time mTransmitDeadlineClock;       ///< deadline for pushing bursts into transmit FIFO 
+  GSM::Time mLastClockUpdateTime;         ///< last time clock update was sent up to core
+
+  RadioInterface *mRadioInterface;	  ///< associated radioInterface object
+  double txFullScale;                     ///< full scale input to radio
+  double rxFullScale;                     ///< full scale output to radio
+
+  double rssiOffset;                      ///< RSSI to dBm conversion offset
+
+  /** modulate and add a burst to the transmit queue */
+  void addRadioVector(size_t chan, BitVector &bits,
+                      int RSSI, GSM::Time &wTime);
+
+  /** Update filler table */
+  void updateFillerTable(size_t chan, radioVector *burst);
+
+  /** Push modulated burst into transmit FIFO corresponding to a particular timestamp */
+  void pushRadioVector(GSM::Time &nowTime);
+
+  /** Pull and demodulate a burst from the receive FIFO */
+  SoftVector *pullRadioVector(GSM::Time &wTime, double &RSSI, bool &isRssiValid,
+                              double &timingOffset, double &noise,
+                              size_t chan = 0);
+
+  /** Set modulus for specific timeslot */
+  void setModulus(size_t timeslot, size_t chan);
+
+  /** return the expected burst type for the specified timestamp */
+  CorrType expectedCorrType(GSM::Time currTime, size_t chan);
+
+  /** send messages over the clock socket */
+  void writeClockInterface(void);
+
+  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
+  double mRxFreq;                      ///< the receive frequency
+  unsigned mTSC;                       ///< the midamble sequence code
+  unsigned mMaxExpectedDelayAB;        ///< maximum expected time-of-arrival offset in GSM symbols for Access Bursts (RACH)
+  unsigned mMaxExpectedDelayNB;        ///< maximum expected time-of-arrival offset in GSM symbols for Normal Bursts
+  unsigned mWriteBurstToDiskMask;      ///< debug: bitmask to indicate which timeslots to dump to disk
+
+  std::vector<TransceiverState> mStates;
+
+  /** Start and stop I/O threads through the control socket API */
+  bool start();
+  void stop();
+
+  /** Protect destructor accessable stop call */
+  Mutex mLock;
+
 protected:
   /** drive lower receive I/O and burst generation */
   void driveReceiveRadio();
@@ -272,7 +251,9 @@ protected:
 
   friend void *TxUpperLoopAdapter(TransceiverChannel *);
 
-  friend void *LowerLoopAdapter(Transceiver *);
+  friend void *RxLowerLoopAdapter(Transceiver *);
+
+  friend void *TxLowerLoopAdapter(Transceiver *);
 
   friend void *ControlServiceLoopAdapter(TransceiverChannel *);
 
@@ -282,12 +263,15 @@ protected:
   /** set priority on current thread */
   void setPriority(float prio = 0.5) { mRadioInterface->setPriority(prio); }
 
+  void logRxBurst(size_t chan, SoftVector *burst, GSM::Time time, double dbm,
+                  double rssi, double noise, double toa);
 };
 
 void *RxUpperLoopAdapter(TransceiverChannel *);
 
 /** Main drive threads */
-void *LowerLoopAdapter(Transceiver *);
+void *RxLowerLoopAdapter(Transceiver *);
+void *TxLowerLoopAdapter(Transceiver *);
 
 /** control message handler thread loop */
 void *ControlServiceLoopAdapter(TransceiverChannel *);

Transceiver52M/USRPDevice.cpp

@@ -59,7 +59,7 @@ const dboardConfigType dboardConfig = TXA_RXB;
 
 const double USRPDevice::masterClockRate = 52.0e6;
 
-USRPDevice::USRPDevice(size_t sps, size_t, bool)
+USRPDevice::USRPDevice(size_t sps)
 {
   LOG(INFO) << "creating USRP device...";
 
@@ -89,7 +89,7 @@ USRPDevice::USRPDevice(size_t sps, size_t, bool)
 #endif
 }
 
-int USRPDevice::open(const std::string &, bool)
+int USRPDevice::open(const std::string &, int, bool)
 {
   writeLock.unlock();
 
@@ -600,7 +600,8 @@ bool USRPDevice::setTxFreq(double wFreq) { return true;};
 bool USRPDevice::setRxFreq(double wFreq) { return true;};
 #endif
 
-RadioDevice *RadioDevice::make(size_t sps, size_t chans, bool diversity)
+RadioDevice *RadioDevice::make(size_t tx_sps, size_t rx_sps,
+			       size_t chans, double)
 {
-	return new USRPDevice(sps, chans, diversity);
+	return new USRPDevice(tx_sps);
 }

Transceiver52M/USRPDevice.h

@@ -96,10 +96,10 @@ private:
  public:
 
   /** Object constructor */
-  USRPDevice(size_t sps, size_t chans = 1, bool diversity = false);
+  USRPDevice(size_t sps);
 
   /** Instantiate the USRP */
-  int open(const std::string &, bool);
+  int open(const std::string &, int, bool);
 
   /** Start the USRP */
   bool start();

Transceiver52M/arm/convert.c

@@ -25,25 +25,12 @@
 #include "config.h"
 #endif
 
-void neon_convert_ps_si16_4n(short *, float *, float *, int);
-void neon_convert_si16_ps_4n(float *, short *, int);
+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, short *in, int len)
-{
-	for (int i = 0; i < len; i++)
-		out[i] = in[i];
-}
-
-static void convert_ps_si16(short *out, 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 *restrict out,
-				 short *restrict in,
+static void neon_convert_si16_ps(float *out,
+				 const short *in,
 				 int len)
 {
 	int start = len / 4 * 4;
@@ -55,9 +42,9 @@ static void neon_convert_si16_ps(float *restrict out,
 }
 
 /* 4*N 16-bit signed integer conversion with remainder */
-static void neon_convert_ps_si16(short *restrict out,
-				 float *restrict in,
-				 float *restrict scale,
+static void neon_convert_ps_si16(short *out,
+				 const float *in,
+				 const float *scale,
 				 int len)
 {
 	int start = len / 4 * 4;
@@ -69,7 +56,7 @@ static void neon_convert_ps_si16(short *restrict out,
 }
 #endif
 
-void convert_float_short(short *out, float *in, float scale, int len)
+void convert_float_short(short *out, const float *in, float scale, int len)
 {
 #ifdef HAVE_NEON
         float q[4] = { scale, scale, scale, scale };
@@ -79,11 +66,11 @@ void convert_float_short(short *out, 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
 }
 
-void convert_short_float(float *out, short *in, int len)
+void convert_short_float(float *out, const short *in, int len)
 {
 #ifdef HAVE_NEON
 	if (len % 4)
@@ -91,6 +78,6 @@ void convert_short_float(float *out, 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

@@ -1,7 +1,15 @@
 #ifndef _CONVERT_H_
 #define _CONVERT_H_
 
-void convert_float_short(short *out, float *in, float scale, int len);
-void convert_short_float(float *out, short *in, int len);
+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

@@ -3,28 +3,30 @@
 
 void *convolve_h_alloc(int num);
 
-int convolve_real(float *x, int x_len,
-		  float *h, int h_len,
+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);
 
-int convolve_complex(float *x, int x_len,
-		     float *h, int h_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 base_convolve_real(float *x, int x_len,
-		       float *h, int h_len,
+int base_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);
 
-int base_convolve_complex(float *x, int x_len,
-			  float *h, int h_len,
+int base_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);
 
+void convolve_init(void);
+
 #endif /* _CONVOLVE_H_ */

Transceiver52M/common/convolve_base.c

@@ -26,21 +26,21 @@
 #endif
 
 /* Base multiply and accumulate complex-real */
-static void mac_real(float *x, float *h, float *y)
+static void mac_real(const float *x, const float *h, float *y)
 {
 	y[0] += x[0] * h[0];
 	y[1] += x[1] * h[0];
 }
 
 /* Base multiply and accumulate complex-complex */
-static void mac_cmplx(float *x, float *h, float *y)
+static void mac_cmplx(const float *x, const float *h, float *y)
 {
 	y[0] += x[0] * h[0] - x[1] * h[1];
 	y[1] += x[0] * h[1] + x[1] * h[0];
 }
 
 /* Base vector complex-complex multiply and accumulate */
-static void mac_real_vec_n(float *x, float *h, float *y,
+static void mac_real_vec_n(const float *x, const float *h, float *y,
 			   int len, int step, int offset)
 {
 	for (int i = offset; i < len; i += step)
@@ -48,7 +48,7 @@ static void mac_real_vec_n(float *x, float *h, float *y,
 }
 
 /* Base vector complex-complex multiply and accumulate */
-static void mac_cmplx_vec_n(float *x, float *h, float *y,
+static void mac_cmplx_vec_n(const float *x, const float *h, float *y,
 			    int len, int step, int offset)
 {
 	for (int i = offset; i < len; i += step)
@@ -56,8 +56,8 @@ static void mac_cmplx_vec_n(float *x, float *h, float *y,
 }
 
 /* Base complex-real convolution */
-int _base_convolve_real(float *x, int x_len,
-			float *h, int h_len,
+int _base_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)
@@ -73,8 +73,8 @@ int _base_convolve_real(float *x, int x_len,
 }
 
 /* Base complex-complex convolution */
-int _base_convolve_complex(float *x, int x_len,
-			   float *h, int h_len,
+int _base_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)
@@ -110,8 +110,8 @@ int bounds_check(int x_len, int h_len, int y_len,
 }
 
 /* API: Non-aligned (no SSE) complex-real */
-int base_convolve_real(float *x, int x_len,
-		       float *h, int h_len,
+int base_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)
@@ -128,8 +128,8 @@ int base_convolve_real(float *x, int x_len,
 }
 
 /* API: Non-aligned (no SSE) complex-complex */
-int base_convolve_complex(float *x, int x_len,
-			  float *h, int h_len,
+int base_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)

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,30 +32,31 @@
 #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)
  *
  *     Other values are invalid. Receive path (uplink) is always
- *     downsampled to 1 sps. Default to 4 sps for all cases except for
- *     ARM and non-SIMD enabled architectures.
+ *     downsampled to 1 sps. Default to 4 sps for all cases.
  */
-#if defined(HAVE_NEON) || !defined(HAVE_SSE3)
-#define DEFAULT_SPS		1
-#else
-#define DEFAULT_SPS		4
-#endif
+#define DEFAULT_TX_SPS		4
 
-/* 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.
+/*
+ * Samples-per-symbol for uplink (receiver) path
+ *     Do not modify this value. EDGE configures 4 sps automatically on
+ *     B200/B210 devices only. Use of 4 sps on the receive path for other
+ *     configurations is not supported.
  */
+#define DEFAULT_RX_SPS		1
+
+/* 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 {
@@ -63,53 +64,25 @@ struct trx_config {
 	std::string addr;
 	std::string dev_args;
 	unsigned port;
-	unsigned sps;
+	unsigned tx_sps;
+	unsigned rx_sps;
 	unsigned chans;
+	unsigned rtsc;
+	unsigned rach_delay;
 	bool extref;
-	bool filler;
-	bool diversity;
-	bool ms;
+	bool gpsref;
+	Transceiver::FillerType filler;
+	bool mcbts;
 	double offset;
+	double rssi_offset;
+	bool swap_channels;
+	bool edge;
 };
 
 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
@@ -119,57 +92,41 @@ bool testConfig()
  */
 bool trx_setup_config(struct trx_config *config)
 {
-	std::string refstr, fillstr, divstr, msstr;
+	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;
+	edgestr = config->edge ? "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";
+		break;
+	case Transceiver::FILLER_ZERO:
+		fillstr = "Disabled";
+		break;
+	case Transceiver::FILLER_NORM_RAND:
+		fillstr = "Normal busrts with random payload";
+		break;
+	case Transceiver::FILLER_EDGE_RAND:
+		fillstr = "EDGE busrts with random payload";
+		break;
+	case Transceiver::FILLER_ACCESS_RAND:
+		fillstr = "Access busrts with random payload";
+		break;
 	}
 
-	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;
-	}
-
-	if (!config->sps)
-		config->sps = DEFAULT_SPS;
-
-	if (!config->chans)
-		config->chans = DEFAULT_CHANS;
-
-	/* Diversity only supported on 2 channels */
-	if (config->diversity)
-		config->chans = 2;
-
-	refstr = config->extref ? "Enabled" : "Disabled";
-	fillstr = config->filler ? "Enabled" : "Disabled";
-	divstr = config->diversity ? "Enabled" : "Disabled";
-	msstr = config->ms ? "Enabled" : "Disabled";
-
 	std::ostringstream ost("");
 	ost << "Config Settings" << std::endl;
 	ost << "   Log Level............... " << config->log_level << std::endl;
@@ -177,12 +134,15 @@ bool trx_setup_config(struct trx_config *config)
 	ost << "   TRX Base Port........... " << config->port << std::endl;
 	ost << "   TRX Address............. " << config->addr << std::endl;
 	ost << "   Channels................ " << config->chans << std::endl;
-	ost << "   Samples-per-Symbol...... " << config->sps << std::endl;
-	ost << "   External Reference...... " << refstr << std::endl;
+	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 << "   Reference............... " << refstr << std::endl;
 	ost << "   C0 Filler Table......... " << fillstr << std::endl;
-	ost << "   Diversity............... " << divstr << std::endl;
-	ost << "   MS Mode................. " << msstr << 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;
 	std::cout << ost << std::endl;
 
 	return true;
@@ -199,31 +159,20 @@ RadioInterface *makeRadioInterface(struct trx_config *config,
                                    RadioDevice *usrp, int type)
 {
 	RadioInterface *radio = NULL;
-	size_t div = 1;
-	int offset = 3;
-
-	if (config->ms) {
-		if (type != RadioDevice::NORMAL) {
-			LOG(ALERT) << "Unsupported configuration";
-			return NULL;
-		}
-
-		offset *= -1;
-	}
 
 	switch (type) {
 	case RadioDevice::NORMAL:
-		radio = new RadioInterface(usrp, config->sps,
-					   config->chans, div, offset);
+		radio = new RadioInterface(usrp, config->tx_sps,
+					   config->rx_sps, config->chans);
 		break;
 	case RadioDevice::RESAMP_64M:
 	case RadioDevice::RESAMP_100M:
-		radio = new RadioInterfaceResamp(usrp,
-						 config->sps, config->chans);
+		radio = new RadioInterfaceResamp(usrp, config->tx_sps,
+						 config->rx_sps);
 		break;
-	case RadioDevice::DIVERSITY:
-		radio = new RadioInterfaceDiversity(usrp,
-						    config->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";
@@ -249,9 +198,11 @@ Transceiver *makeTransceiver(struct trx_config *config, RadioInterface *radio)
 	Transceiver *trx;
 	VectorFIFO *fifo;
 
-	trx = new Transceiver(config->port, config->addr.c_str(), config->sps,
-			      config->chans, GSM::Time(3,0), radio);
-	if (!trx->init(config->filler)) {
+	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, config->edge)) {
 		LOG(ALERT) << "Failed to initialize transceiver";
 		delete trx;
 		return NULL;
@@ -296,13 +247,20 @@ static void print_help()
 		"  -l    Logging level (%s)\n"
 		"  -i    IP address of GSM core\n"
 		"  -p    Base port number\n"
-		"  -d    Enable dual channel diversity receiver\n"
+		"  -e    Enable EDGE 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"
-		"  -m    Enable MS mode\n"
-		"  -o    Set baseband frequency offset (default=auto)\n",
+		"  -o    Set baseband frequency offset (default=auto)\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",
 		"EMERG, ALERT, CRT, ERR, WARNING, NOTICE, INFO, DEBUG");
 }
 
@@ -310,16 +268,24 @@ static void handle_options(int argc, char **argv, struct trx_config *config)
 {
 	int option;
 
-	config->port = 0;
-	config->sps = 0;
-	config->chans = 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->filler = false;
-	config->diversity = false;
-	config->ms = false;
+	config->gpsref = false;
+	config->filler = Transceiver::FILLER_ZERO;
+	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:ms:")) != -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();
@@ -340,44 +306,121 @@ 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 = true;
+			config->filler = Transceiver::FILLER_DUMMY;
 			break;
 		case 'o':
 			config->offset = atof(optarg);
 			break;
-		case 'm':
-			config->ms = true;
-			break;
 		case 's':
-			config->sps = atoi(optarg);
-			if ((config->sps != 1) && (config->sps != 4)) {
-				printf("Unsupported samples-per-symbol\n\n");
-				print_help();
-				exit(0);
-			}
+			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;
+			break;
+		case 'R':
+			config->rssi_offset = atof(optarg);
+			break;
+		case 'S':
+			config->swap_channels = true;
+			break;
+		case 'e':
+			config->edge = true;
 			break;
 		default:
 			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->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);
+		goto bad_config;
+	}
+
+	if (config->rach_delay > 68) {
+		printf("RACH delay is too big %i\n\n", config->rach_delay);
+		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();
@@ -393,9 +436,19 @@ int main(int argc, char *argv[])
 	srandom(time(NULL));
 
 	/* Create the low level device object */
-	usrp = RadioDevice::make(config.sps, config.chans,
-				 config.diversity, config.offset);
-	type = usrp->open(config.dev_args, config.extref);
+	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;
@@ -411,8 +464,6 @@ int main(int argc, char *argv[])
 	if (!trx)
 		goto shutdown;
 
-	trx->start();
-
 	chans = trx->numChans();
 	std::cout << "-- Transceiver active with "
 		  << chans << " channel(s)" << std::endl;

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/radioClock.cpp

@@ -23,66 +23,27 @@
 
 void RadioClock::set(const GSM::Time& wTime)
 {
-	mLock.lock();
+	ScopedLock lock(mLock);
 	mClock = wTime;
 	updateSignal.signal();
-	mLock.unlock();
-}
-
-GSM::Time RadioClock::adjust(GSM::Time &wBase, GSM::Time &wOffset)
-{
-	int tn_diff, fn_diff = 0;
-
-	/* Modulo TN adustment */
-	tn_diff = wBase.TN() + wOffset.TN();
-	if (tn_diff < 0) {
-		tn_diff += 8;
-		fn_diff--;
-	} else if (tn_diff >= 8) {
-		tn_diff -= 8;
-		fn_diff++;
-	}
-
-	/* Modulo FN adjustment */
-	fn_diff += wBase.FN() + wOffset.FN();
-	if (fn_diff < 0)
-		fn_diff += GSM::gHyperframe;
-	else if ((unsigned) fn_diff >= GSM::gHyperframe)
-		fn_diff = fn_diff - GSM::gHyperframe;
-
-	return GSM::Time(fn_diff, tn_diff);
-}
-
-void RadioClock::adjust(GSM::Time& wOffset)
-{
-	mLock.lock();
-
-	mClock = adjust(mClock, wOffset); 
-	updateSignal.signal();
-
-	mLock.unlock();
 }
 
 void RadioClock::incTN()
 {
-	mLock.lock();
+	ScopedLock lock(mLock);
 	mClock.incTN();
 	updateSignal.signal();
-	mLock.unlock();
 }
 
 GSM::Time RadioClock::get()
 {
-	mLock.lock();
+	ScopedLock lock(mLock);
 	GSM::Time retVal = mClock;
-	mLock.unlock();
-
 	return retVal;
 }
 
 void RadioClock::wait()
 {
-	mLock.lock();
+	ScopedLock lock(mLock);
 	updateSignal.wait(mLock,1);
-	mLock.unlock();
 }

Transceiver52M/radioClock.h

@@ -26,10 +26,7 @@
 
 class RadioClock {
 public:
-	static GSM::Time adjust(GSM::Time &base, GSM::Time &offset);
-
 	void set(const GSM::Time& wTime);
-	void adjust(GSM::Time &wOffset);
 	void incTN();
 	GSM::Time get();
 	void wait();

Transceiver52M/radioDevice.h

@@ -22,7 +22,8 @@
 #include "config.h"
 #endif
 
-#define GSMRATE       1625e3/6
+#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 sps, 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)=0;
+  virtual int open(const std::string &args, int ref, bool swap_channels)=0;
 
   virtual ~RadioDevice() { }
 
@@ -91,9 +103,6 @@ class RadioDevice {
   /** Set the receiver frequency */
   virtual bool setRxFreq(double wFreq, size_t chan = 0) = 0;
 
-  /** Adjust the receiver offset */
-  virtual bool setRxOffset(double wOffset, size_t chan = 0) = 0;
-
   /** Returns the starting write Timestamp*/
   virtual TIMESTAMP initialWriteTimestamp(void)=0;
 

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"
@@ -33,13 +31,11 @@ extern "C" {
 #define CHUNK		625
 #define NUMCHUNKS	4
 
-RadioInterface::RadioInterface(RadioDevice *wRadio,
-                               size_t sps, size_t chans, size_t diversity,
+RadioInterface::RadioInterface(RadioDevice *wRadio, size_t tx_sps,
+                               size_t rx_sps, size_t chans,
                                int wReceiveOffset, GSM::Time wStartTime)
-  : mRadio(wRadio), mSPSTx(sps), mSPSRx(1), mChans(chans), mMIMO(diversity),
-    sendCursor(0), recvCursor(0), underrun(false), overrun(false),
-    receiveOffset(wReceiveOffset), shiftOffset(0), shiftUpdate(false),
-    mOn(false)
+  : mRadio(wRadio), mSPSTx(tx_sps), mSPSRx(rx_sps), mChans(chans),
+    underrun(false), overrun(false), receiveOffset(wReceiveOffset), mOn(false)
 {
   mClock.set(wStartTime);
 }
@@ -51,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;
   }
@@ -66,33 +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);
@@ -107,60 +90,50 @@ double RadioInterface::fullScaleOutputValue(void) {
   return mRadio->fullScaleOutputValue();
 }
 
-
-void RadioInterface::setPowerAttenuation(double atten, size_t chan)
+int RadioInterface::setPowerAttenuation(int atten, size_t chan)
 {
   double rfGain, digAtten;
 
   if (chan >= mChans) {
     LOG(ALERT) << "Invalid channel requested";
-    return;
+    return -1;
   }
 
-  rfGain = mRadio->setTxGain(mRadio->maxTxGain() - atten, chan);
-  digAtten = atten - mRadio->maxTxGain() + rfGain;
+  if (atten < 0.0)
+    atten = 0.0;
+
+  rfGain = mRadio->setTxGain(mRadio->maxTxGain() - (double) atten, chan);
+  digAtten = (double) atten - mRadio->maxTxGain() + rfGain;
 
   if (digAtten < 1.0)
     powerScaling[chan] = 1.0;
   else
     powerScaling[chan] = 1.0 / sqrt(pow(10, digAtten / 10.0));
+
+  return atten;
 }
 
 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();
-}
-
-void RadioInterface::adjustClock(GSM::Time &offset)
-{
-  mClock.adjust(offset);
+  return newVector->size();
 }
 
 bool RadioInterface::tuneTx(double freq, size_t chan)
@@ -173,19 +146,25 @@ bool RadioInterface::tuneRx(double freq, size_t chan)
   return mRadio->setRxFreq(freq, chan);
 }
 
-bool RadioInterface::tuneRxOffset(double offset, size_t chan)
+bool RadioInterface::start()
 {
-  return mRadio->setRxOffset(offset, chan);
-}
+  if (mOn)
+    return true;
 
-void RadioInterface::start()
-{
-  LOG(INFO) << "Starting radio";
+  LOG(INFO) << "Starting radio device";
 #ifdef USRP1
   mAlignRadioServiceLoopThread.start((void * (*)(void*))AlignRadioServiceLoopAdapter,
                                      (void*)this);
 #endif
-  mRadio->start();
+
+  if (!mRadio->start())
+    return false;
+
+  for (size_t i = 0; i < mChans; i++) {
+    sendBuffer[i]->reset();
+    recvBuffer[i]->reset();
+  }
+
   writeTimestamp = mRadio->initialWriteTimestamp();
   readTimestamp = mRadio->initialReadTimestamp();
 
@@ -194,6 +173,23 @@ void RadioInterface::start()
 
   mOn = true;
   LOG(INFO) << "Radio started";
+  return true;
+}
+
+/*
+ * Stop the radio device
+ *
+ * This is a pass-through call to the device interface. Because the underlying
+ * stop command issuance generally doesn't return confirmation on device status,
+ * this call will only return false if the device is already stopped.
+ */
+bool RadioInterface::stop()
+{
+  if (!mOn || !mRadio->stop())
+    return false;
+
+  mOn = false;
+  return true;
 }
 
 #ifdef USRP1
@@ -218,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()
@@ -238,16 +230,16 @@ bool RadioInterface::driveReceiveRadio()
   pullBuffer();
 
   GSM::Time rcvClock = mClock.get();
-  if (receiveOffset < 0)
-    rcvClock.incTN(-receiveOffset);
-  else
-    rcvClock.decTN(receiveOffset);
-
+  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 = (symbolsPerSlot + (tN % 4 == 0)) * mSPSRx;
+  int burstSize;
+
+  if (mSPSRx == 4)
+    burstSize = 625;
+  else
+    burstSize = symbolsPerSlot + (tN % 4 == 0);
 
   /* 
    * Pre-allocate head room for the largest correlation size
@@ -261,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);
@@ -277,22 +264,12 @@ bool RadioInterface::driveReceiveRadio()
 
     mClock.incTN();
     rcvClock.incTN();
-    readSz += burstSize;
     recvSz -= burstSize;
 
     tN = rcvClock.TN();
 
-    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;
+    if (mSPSRx != 4)
+      burstSize = (symbolsPerSlot + (tN % 4 == 0)) * mSPSRx;
   }
 
   return true;
@@ -306,12 +283,6 @@ bool RadioInterface::isUnderrun()
   return retVal;
 }
 
-void RadioInterface::applyOffset(int offset)
-{
-  shiftOffset += offset;
-  shiftUpdate = true;
-}
-
 VectorFIFO* RadioInterface::receiveFIFO(size_t chan)
 {
   if (chan >= mReceiveFIFO.size())
@@ -322,79 +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 + shiftOffset,
-                                 &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);
   }
 
-  if (shiftUpdate) {
-    mRadio->updateAlignment(0);
-    shiftUpdate = false;
-  }
+  /* Send the all samples in the send buffer */
+  numSent = mRadio->writeSamples(convertSendBuffer,
+                                 segmentLen,
+                                 &underrun,
+                                 writeTimestamp);
+  writeTimestamp += numSent;
 
-  /* Send the all samples in the send buffer */ 
-  num_sent = mRadio->writeSamples(convertSendBuffer,
-                                  sendCursor,
-                                  &underrun,
-                                  writeTimestamp + mSPSTx * shiftOffset);
-  writeTimestamp += num_sent;
-  sendCursor = 0;
+  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;
@@ -56,22 +56,19 @@ protected:
   RadioClock mClock;                          ///< the basestation clock!
 
   int receiveOffset;                          ///< offset b/w transmit and receive GSM timestamps, in timeslots
-  int shiftOffset;
-  bool shiftUpdate;
+
   bool mOn;				      ///< indicates radio is on
 
 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);
@@ -79,23 +76,23 @@ private:
 public:
 
   /** start the interface */
-  void start();
+  bool start();
+  bool stop();
 
   /** intialization */
   virtual bool init(int type);
   virtual void close();
 
   /** constructor */
-  RadioInterface(RadioDevice* wRadio = NULL,
-                 size_t sps = 4, 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();
 
   /** check for underrun, resets underrun value */
   bool isUnderrun();
-  void applyOffset(int offset);
 
   /** return the receive FIFO */
   VectorFIFO* receiveFIFO(size_t chan = 0);
@@ -103,18 +100,12 @@ public:
   /** return the basestation clock */
   RadioClock* getClock(void) { return &mClock;};
 
-  /** apply an offset to the main clock */
-  void adjustClock(GSM::Time &offset);
-
   /** 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);
 
-  /** set frequency correction */
-  virtual bool tuneRxOffset(double offset, size_t chan = 0);
-
   /** set receive gain */
   double setRxGain(double dB, size_t chan = 0);
 
@@ -128,7 +119,7 @@ public:
   /** drive reception of GSM bursts */
   bool driveReceiveRadio();
 
-  void setPowerAttenuation(double atten, size_t chan = 0);
+  int setPowerAttenuation(int atten, size_t chan = 0);
 
   /** returns the full-scale transmit amplitude **/
   double fullScaleInputValue();
@@ -158,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 + shiftOffset,
-				  &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,14 +165,14 @@ 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 */
 	num_recv = mRadio->readSamples(convertRecvBuffer,
 				       resamp_outchunk,
 				       &overrun,
-				       readTimestamp + shiftOffset,
+				       readTimestamp,
 				       &local_underrun);
 	if (num_recv != (int) resamp_outchunk) {
 		LOG(ALERT) << "Receive error " << num_recv;
@@ -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/radioVector.cpp

@@ -74,31 +74,25 @@ bool radioVector::setVector(signalVector *vector, size_t chan)
 	return true;
 }
 
-avgVector::avgVector(size_t max)
-	: std::vector<float>(0), itr(0)
+noiseVector::noiseVector(size_t size)
+	: std::vector<float>(size), itr(0)
 {
-	this->max = max;
 }
 
-float avgVector::avg() const
+float noiseVector::avg() const
 {
 	float val = 0.0;
 
-	if (!size())
-		return 0.0f;
-
 	for (size_t i = 0; i < size(); i++)
 		val += (*this)[i];
 
 	return val / (float) size();
 }
 
-bool avgVector::insert(float val)
+bool noiseVector::insert(float val)
 {
-	if (size() < max) {
-		push_back(val);
-		return true;
-	}
+	if (!size())
+		return false;
 
 	if (itr >= this->size())
 		itr = 0;
@@ -108,16 +102,6 @@ bool avgVector::insert(float val)
 	return true;
 }
 
-bool avgVector::full() const
-{
-	return size() >= max;
-}
-
-void avgVector::reset()
-{
-	resize(0);
-}
-
 GSM::Time VectorQueue::nextTime() const
 {
 	GSM::Time retVal;

Transceiver52M/radioVector.h

@@ -46,17 +46,14 @@ private:
 	GSM::Time mTime;
 };
 
-class avgVector : std::vector<float> {
+class noiseVector : std::vector<float> {
 public:
-	avgVector(size_t size = 0);
+	noiseVector(size_t size = 0);
 	bool insert(float val);
-	bool full() const;
 	float avg() const;
-	void reset();
 
 private:
 	size_t itr;
-	size_t max;
 };
 
 class VectorFIFO : public InterthreadQueue<radioVector> { };

Transceiver52M/sch.c

@@ -1,219 +0,0 @@
-#include <complex.h>
-#include <stdio.h>
-#include <math.h>
-#include <string.h>
-
-#include <osmocom/core/bits.h>
-#include <osmocom/core/conv.h>
-#include <osmocom/core/utils.h>
-#include <osmocom/core/crcgen.h>
-
-#include "sch.h"
-
-/* GSM 04.08, 9.1.30 Synchronization channel information */
-struct sch_packed_info {
-	ubit_t t1_hi[2];
-	ubit_t bsic[6];
-	ubit_t t1_md[8];
-	ubit_t t3p_hi[2];
-	ubit_t t2[5];
-	ubit_t t1_lo[1];
-	ubit_t t3p_lo[1];
-} __attribute__((packed));
-
-struct sch_burst {
-	sbit_t tail0[3];
-	sbit_t data0[39];
-	sbit_t etsc[64];
-	sbit_t data1[39];
-	sbit_t tail1[3];
-	sbit_t guard[8];
-} __attribute__((packed));
-
-static const uint8_t sch_next_output[][2] = {
-	{ 0, 3 }, { 1, 2 }, { 0, 3 }, { 1, 2 },
-	{ 3, 0 }, { 2, 1 }, { 3, 0 }, { 2, 1 },
-	{ 3, 0 }, { 2, 1 }, { 3, 0 }, { 2, 1 },
-	{ 0, 3 }, { 1, 2 }, { 0, 3 }, { 1, 2 },
-};
-
-static const uint8_t sch_next_state[][2] = {
-	{  0,  1 }, {  2,  3 }, {  4,  5 }, {  6,  7 },
-	{  8,  9 }, { 10, 11 }, { 12, 13 }, { 14, 15 },
-	{  0,  1 }, {  2,  3 }, {  4,  5 }, {  6,  7 },
-	{  8,  9 }, { 10, 11 }, { 12, 13 }, { 14, 15 },
-};
-
-static const struct osmo_conv_code gsm_conv_sch = {
-	.N = 2,
-	.K = 5,
-	.len = GSM_SCH_UNCODED_LEN,
-	.next_output = sch_next_output,
-	.next_state  = sch_next_state,
-};
-
-const struct osmo_crc16gen_code gsm0503_sch_crc10 = {
-	.bits = 10,
-	.poly = 0x175,
-	.init = 0x000,
-	.remainder = 0x3ff,
-};
-
-#define GSM_MAX_BURST_LEN	157
-#define GSM_SYM_RATE		(1625e3 / 6)
-
-/* Pre-generated FCCH measurement tone */
-static complex float fcch_ref[GSM_MAX_BURST_LEN];
-
-int float_to_sbit(const float *in, sbit_t *out, float scale, int len)
-{
-	int i;
-
-	for (i = 0; i < len; i++) {
-		out[i] = (in[i] - 0.5f) * scale;
-	}
-
-	return 0;
-}
-
-/* Check if FN contains a SCH burst */
-int gsm_sch_check_fn(int fn)
-{
-	int fn51 = fn % 51;
-
-	switch (fn51) {
-	case 1:
-	case 11:
-	case 21:
-	case 31:
-	case 41:
-		return 1;
-	}
-
-	return 0;
-}
-
-/* SCH (T1, T2, T3p) to full FN value */
-int gsm_sch_to_fn(struct sch_info *sch)
-{
-	int t1 = sch->t1;
-	int t2 = sch->t2;
-	int t3p = sch->t3p;
-
-	if ((t1 < 0) || (t2 < 0) || (t3p < 0))
-		return -1;
-	int tt;
-	int t3 = t3p * 10 + 1;
-
-	if (t3 < t2)
-		tt = (t3 + 26) - t2;
-	else
-		tt = (t3 - t2) % 26;
-
-	return t1 * 51 * 26 + tt * 51 + t3;
-}
-
-/* Parse encoded SCH message */
-int gsm_sch_parse(const uint8_t *info, struct sch_info *desc)
-{
-	struct sch_packed_info *p = (struct sch_packed_info *) info;
-
-	desc->bsic = (p->bsic[0] << 0) | (p->bsic[1] << 1) |
-		     (p->bsic[2] << 2) | (p->bsic[3] << 3) |
-		     (p->bsic[4] << 4);
-
-	desc->t1 = (p->t1_lo[0] << 0) | (p->t1_md[0] << 1) |
-		   (p->t1_md[1] << 2) | (p->t1_md[2] << 3) |
-		   (p->t1_md[3] << 4) | (p->t1_md[4] << 5) |
-		   (p->t1_md[5] << 6) | (p->t1_md[6] << 7) |
-		   (p->t1_md[7] << 8) | (p->t1_hi[0] << 9) |
-		   (p->t1_hi[1] << 10);
-
-	desc->t2 = (p->t2[0] << 0) | (p->t2[1] << 1) |
-		   (p->t2[2] << 2) | (p->t2[3] << 3) |
-		   (p->t2[4] << 4);
-
-	desc->t3p = (p->t3p_lo[0] << 0) | (p->t3p_hi[0] << 1) |
-		    (p->t3p_hi[1] << 2);
-
-	return 0;
-}
-
-/* From osmo-bts */
-int gsm_sch_decode(uint8_t *info, sbit_t *data)
-{
-	int rc;
-	ubit_t uncoded[GSM_SCH_UNCODED_LEN];
-
-	osmo_conv_decode(&gsm_conv_sch, data, uncoded);
-
-	rc = osmo_crc16gen_check_bits(&gsm0503_sch_crc10,
-				      uncoded, GSM_SCH_INFO_LEN,
-				      uncoded + GSM_SCH_INFO_LEN);
-	if (rc)
-		return -1;
-
-	memcpy(info, uncoded, GSM_SCH_INFO_LEN * sizeof(ubit_t));
-
-	return 0;
-}
-
-#define FCCH_TAIL_BITS_LEN	3
-#define FCCH_DATA_LEN		142
-
-/* Compute FCCH frequency offset */
-double gsm_fcch_offset(float *burst, int len)
-{
-	int i, start, end;
-	float a, b, c, d, ang, avg = 0.0f;
-	double freq;
-
-	if (len > GSM_MAX_BURST_LEN)
-		len = GSM_MAX_BURST_LEN;
-
-	for (i = 0; i < len; i++) {
-		a = burst[2 * i + 0];
-		b = burst[2 * i + 1];
-		c = crealf(fcch_ref[i]);
-		d = cimagf(fcch_ref[i]);
-
-		burst[2 * i + 0] = a * c - b * d;
-		burst[2 * i + 1] = a * d + b * c;
-	}
-
-	start = FCCH_TAIL_BITS_LEN;
-	end = start + FCCH_DATA_LEN;
-
-	for (i = start; i < end; i++) {
-		a = cargf(burst[2 * (i - 1) + 0] +
-			  burst[2 * (i - 1) + 1] * I);
-		b = cargf(burst[2 * i + 0] +
-			  burst[2 * i + 1] * I);
-
-		ang = b - a;
-
-		if (ang > M_PI)
-			ang -= 2 * M_PI;
-		else if (ang < -M_PI)
-			ang += 2 * M_PI;
-
-		avg += ang;
-	}
-
-	avg /= (float) (end - start);
-	freq = avg / (2 * M_PI) * GSM_SYM_RATE;
-
-	return freq;
-}
-
-/* Generate FCCH measurement tone */
-static __attribute__((constructor)) void init()
-{
-	int i;
-	double freq = 0.25;
-
-	for (i = 0; i < GSM_MAX_BURST_LEN; i++) {
-		fcch_ref[i] = sin(2 * M_PI * freq * (double) i) +
-			      cos(2 * M_PI * freq * (double) i) * I;
-	}
-}

Transceiver52M/sch.h

@@ -1,26 +0,0 @@
-#ifndef _SCH_H_
-#define _SCH_H_
-
-#include <osmocom/core/bits.h>
-
-struct sch_info  {
-	int bsic;
-	int t1;
-	int t2;
-	int t3p;
-};
-
-#define GSM_SCH_INFO_LEN		25
-#define GSM_SCH_UNCODED_LEN		35
-#define GSM_SCH_CODED_LEN		78
-
-int gsm_sch_decode(uint8_t *sb_info, sbit_t *burst);
-int gsm_sch_parse(const uint8_t *sb_info, struct sch_info *desc);
-int gsm_sch_to_fn(struct sch_info *sch);
-int gsm_sch_check_fn(int fn);
-
-double gsm_fcch_offset(float *burst, int len);
-
-int float_to_sbit(const float *in, sbit_t *out, float scale, int len);
-
-#endif /* _SCH_H_ */

Transceiver52M/sigProcLib.h

@@ -18,8 +18,14 @@
 #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)
+
 /** Convolution type indicator */
 enum ConvType {
   START_ONLY,
@@ -28,6 +34,34 @@ enum ConvType {
   UNDEFINED,
 };
 
+/** 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,
+  SIGERR_UNSUPPORTED,
+  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);
 
@@ -41,70 +75,89 @@ float vectorNorm2(const signalVector &x);
 float vectorPower(const signalVector &x);
 
 /** Setup the signal processing library */
-bool sigProcLibSetup(int sps);
+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,
+                                int sps, bool emptyPulse = false);
+
+/** Generate a EDGE burst with random payload - 4 SPS (625 samples) only */
+signalVector *generateEdgeBurst(int tsc);
+
+/** Generate an empty burst - 4 or 1 SPS */
+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, PRBS &prbs);
+
+/** Generate an access GSM burst with random payload - 4 or 1 SPS */
+signalVector *genRandAccessBurst(int delay, int sps, int tn);
+
+/** Generate a dummy GSM burst - 4 or 1 SPS */
+signalVector *generateDummyBurst(int sps, int tn);
 
 /** Sinc function */
 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,
@@ -116,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.
@@ -141,91 +194,109 @@ complex peakDetect(const signalVector &rxBurst,
         @param scale The scalar.
 */
 void scaleVector(signalVector &x,
-		 complex scale);
+                 complex scale);
 
 /**
-        Generate a modulated GSM midamble, stored within the library.
-        @param gsmPulse The GSM pulse used for modulation.
-        @param sps The number of samples per GSM symbol.
-        @param TSC The training sequence [0..7]
-        @return Success.
-*/
-bool generateMidamble(int sps, int tsc);
-/**
-        Generate a modulated RACH sequence, stored within the library.
-        @param gsmPulse The GSM pulse used for modulation.
-        @param sps The number of samples per GSM symbol.
-        @return Success.
-*/
-bool generateRACHSequence(int sps);
-bool generateSCHSequence(int sps);
-
-/**
-        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.
-        @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);
-
-enum {
-	SCH_DETECT_FULL,
-	SCH_DETECT_NARROW,
-};
-
-int detectSCHBurst(signalVector &rxBurst,
-                    float detectThreshold,
-                    int sps,
-                    complex *amplitude,
-                    float* TOA, int state);
+                    complex &amplitude,
+                    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 sps,
-			complex *amplitude,
-			float *TOA,
-                        unsigned maxTOA,
-                        bool requestChannel = false,
-			signalVector** channelResponse = NULL,
-			float *channelResponseOffset = NULL);
+int analyzeTrafficBurst(const signalVector &burst,
+                        unsigned tsc,
+                        float threshold,
+                        int sps,
+                        complex &amplitude,
+                        float &toa,
+                        unsigned max_toa);
 
 /**
-	Decimate a vector.
+        EDGE/8-PSK Normal Burst correlator/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.
+        @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(const signalVector &burst,
+                    unsigned tsc,
+                    float threshold,
+                    int sps,
+                    complex &amplitude,
+                    float &toa,
+                    unsigned max_toa);
+
+/**
+        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(const signalVector &burst);
+
+/**
+        Decimate a vector.
         @param wVector The vector of interest.
         @param factor Decimation factor.
         @return The decimated signal vector.
@@ -233,45 +304,30 @@ int analyzeTrafficBurst(signalVector &rxBurst,
 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);
 
 /**
-	Design the necessary filters for a decision-feedback equalizer.
-	@param channelResponse The multipath channel that we're mitigating.
-	@param SNRestimate The signal-to-noise estimate of the channel, a linear value
-	@param Nf The number of taps in the feedforward filter.
-	@param feedForwardFilter The designed feed forward filter.
-	@param feedbackFilter The designed feedback filter.
-	@return True if DFE can be designed.
+        Demodulate 8-PSK EDGE burst with soft symbol ooutput
+        @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.
 */
-bool designDFE(signalVector &channelResponse,
-	       float SNRestimate,
-	       int Nf,
-	       signalVector **feedForwardFilter,
-	       signalVector **feedbackFilter);
+SoftVector *demodEdgeBurst(const signalVector &rxBurst, int sps,
+                           complex channel, float TOA);
 
-/**
-	Equalize/demodulate a received burst via a decision-feedback equalizer.
-	@param rxBurst The received burst to be demodulated.
-	@param TOA The time-of-arrival of the received burst.
-	@param sps The number of samples per GSM symbol.
-	@param w The feed forward filter of the DFE.
-	@param b The feedback filter of the DFE.
-	@return The demodulated bit sequence.
-*/
-SoftVector *equalizeBurst(signalVector &rxBurst,
-		       float TOA,
-		       int sps,
-		       signalVector &w, 
-		       signalVector &b);
+/** 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../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,181 +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,
-				     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,
-				 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,
-					  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,
-				       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,
-					   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, 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, short *in, int len)
-{
-	for (int i = 0; i < len; i++)
-		out[i] = in[i];
-}
-#endif
-
-void convert_float_short(short *out, float *in, float scale, int len)
-{
 #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)
+{
 	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, short *in, int 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,20 +21,46 @@
 #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(float *x, int x_len,
-			float *h, int h_len,
+int _base_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);
 
-int _base_convolve_complex(float *x, int x_len,
-			   float *h, int h_len,
+int _base_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);
@@ -42,560 +68,105 @@ int _base_convolve_complex(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(float *restrict x,
-			   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(float *restrict x,
-			   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(float *restrict x,
-			    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(float *restrict x,
-			    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(float *restrict x,
-			    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(float *x, 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(float *x, 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(float *x, 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(float *x, int x_len,
-		  float *h, int h_len,
-		  float *y, int y_len,
-		  int start, int len,
-		  int step, int offset)
+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)
 {
-	void (*conv_func)(float *, float *, float *, int) = NULL;
-	void (*conv_func_n)(float *, 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;
 }
 
 /* API: Aligned complex-complex */
-int convolve_complex(float *x, int x_len,
-		     float *h, int h_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)(float *, 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

@@ -29,7 +29,7 @@ AC_CANONICAL_BUILD
 AC_CANONICAL_HOST
 AC_CANONICAL_TARGET
 
-AM_INIT_AUTOMAKE
+AM_INIT_AUTOMAKE([subdir-objects])
 
 dnl Linux kernel KBuild style compile messages
 m4_ifdef([AM_SILENT_RULES], [AM_SILENT_RULES([yes])])
@@ -58,9 +58,6 @@ AC_TYPE_SIZE_T
 AC_HEADER_TIME
 AC_C_BIGENDIAN
 
-dnl checks for libraries
-PKG_CHECK_MODULES(LIBOSMOCORE, libosmocore  >= 0.3.9)
-
 AC_ARG_WITH(usrp1, [
     AS_HELP_STRING([--with-usrp1],
         [enable USRP1 gnuradio based transceiver])
@@ -81,6 +78,11 @@ AC_ARG_WITH(neon-vfpv4, [
         [enable ARM NEON FMA support])
 ])
 
+AC_ARG_WITH(sse, [
+    AS_HELP_STRING([--with-sse],
+        [enable x86 SSE support (default)])
+])
+
 AS_IF([test "x$with_neon" = "xyes"], [
     AC_DEFINE(HAVE_NEON, 1, Support ARM NEON)
 ])
@@ -95,8 +97,15 @@ AS_IF([test "x$with_usrp1" = "xyes"], [
 ])
 
 AS_IF([test "x$with_usrp1" != "xyes"],[
-    PKG_CHECK_MODULES(UHD, uhd >= 003.004.000)
-    AC_DEFINE(USE_UHD, 1, Define to 1 if using UHD)
+    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"], [
@@ -104,13 +113,24 @@ AS_IF([test "x$with_singledb" = "xyes"], [
 ])
 
 # Find and define supported SIMD extensions
-AX_EXT
+AS_IF([test "x$with_sse" != "xno"], [
+    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([\
@@ -120,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

@@ -0,0 +1,11 @@
+osmo-trx (0.1.9) trusty; urgency=medium
+
+  * Ask Ivan, really
+
+ -- Kirill Zakharenko <earwin@gmail.com>  Thu, 16 Jul 2015 12:13:46 +0000
+
+osmo-trx (0.1.8) precise; urgency=low
+
+     * 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/compat

@@ -0,0 +1 @@
+9

debian/control

@@ -0,0 +1,46 @@
+Source: osmo-trx
+Section: net
+Priority: optional
+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: 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
+Section: debug
+Priority: extra
+Depends: osmo-trx (= ${binary:Version}), ${misc:Depends}
+Description: Debug symbols for the osmo-trx
+ Make debugging possible

debian/copyright

@@ -0,0 +1,161 @@
+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
+
+Files: *
+Copyright: 2008-2013 Free Software Foundation
+           2010 Kestrel Signal Processing, Inc.
+           2010-2012 Range Networks, Inc.
+License: AGPL-3+
+
+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+
+
+Files: config/ax_check_compile_flag.m4
+Copyright: 2008 Guido U. Draheim <guidod@gmx.de>
+           2011 Maarten Bosmans <mkbosmans@gmail.com>
+License: GPL-3+
+
+Files: config/ax_gcc_x86_cpuid.m4
+Copyright: 2008 Steven G. Johnson <stevenj@alum.mit.edu>
+           2008 Matteo Frigo
+License: GPL-3+
+
+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
+
+Files: config/ax_gcc_x86_avx_xgetbv.m4
+Copyright: 2013 Michael Petch <mpetch@capp-sysware.com>
+License: GPL-3+
+
+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+
+
+Files: autogen.sh
+Copyright: 2005-2009 United States Government as represented by
+                     the U.S. Army Research Laboratory.
+License: BSD-3-clause
+
+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/osmo-trx.install

@@ -0,0 +1 @@
+/usr/bin/osmo-trx

debian/rules

@@ -0,0 +1,12 @@
+#!/usr/bin/make -f
+
+export DEB_BUILD_MAINT_OPTIONS = hardening=+all
+
+%:
+	dh $@ --with autoreconf
+
+override_dh_shlibdeps:
+	dh_shlibdeps --dpkg-shlibdeps-params=--ignore-missing-info
+
+override_dh_strip:
+	dh_strip --dbg-package=osmo-trx-dbg

debian/source/format

@@ -0,0 +1 @@
+3.0 (native)