5 bit ramp-up/ramp-down

Conflicts:

	Transceiver52M/UHDDevice.cpp

.gitignore

@@ -1,46 +0,0 @@
-# build results
-*.o
-*.lo
-*.la
-Transceiver52M/osmo-trx
-
-# 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

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

CMakeLists.txt

@@ -1,51 +0,0 @@
-cmake_minimum_required(VERSION 2.8)
-project(osmo-trx C CXX)
-
-set(CMAKE_CXX_STANDARD 11)
-
-# Set the version information here
-set(MAJOR_VERSION 0)
-set(API_COMPAT    0)
-set(MINOR_VERSION 1)
-set(MAINT_VERSION git)
-
-set(LIBVER  "${MAJOR_VERSION}.${API_COMPAT}.${MINOR_VERSION}")
-
-include_directories(CommonLibs)
-include_directories(GSM)
-
-add_definitions(-Wall -g)
-
-#set(BUILD_SHARED_LIBS ON)
-
-CONFIGURE_FILE(
-    ${CMAKE_CURRENT_SOURCE_DIR}/cmake_config.in.h
-    ${CMAKE_CURRENT_BINARY_DIR}/config.h
-@ONLY)
-
-set(CMAKE_MODULE_PATH ${CMAKE_CURRENT_SOURCE_DIR}/cmake)
-
-option(TRANS_FULL_VERSION "Compile with all Multichannel/Resampler support" OFF)
-#option(SQLITE_CONFIG      "Use config values from SQLite3 database" OFF)
-set(SQLITE_CONFIG ON)
-
-if(TRANS_FULL_VERSION)
-    find_package(FFTW)
-endif(TRANS_FULL_VERSION)
-
-find_package(XTRX)
-
-if(SQLITE_CONFIG)
-    find_library(sqlite3 sqlite3)
-else(SQLITE_CONFIG)
-    add_definitions(-DNO_SQLITE_CONFIG)
-endif(SQLITE_CONFIG)
-
-include_directories(${CMAKE_CURRENT_BINARY_DIR})
-
-
-add_subdirectory(CommonLibs)
-add_subdirectory(GSM)
-add_subdirectory(Transceiver52M)
-
-

CommonLibs/BitVector.cpp

@@ -200,6 +200,49 @@ 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;
@@ -245,12 +288,148 @@ 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]=-1.0F;
+		else mStart[i]=0.0F;
 	}
 }
 
@@ -260,20 +439,103 @@ BitVector SoftVector::sliced() const
 	size_t sz = size();
 	BitVector newSig(sz);
 	for (size_t i=0; i<sz; i++) {
-		if (mStart[i]>0.0F) newSig[i]=1;
+		if (mStart[i]>0.5F) 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 energy = fabsf(vec[i]);
+		float bit = vec[i];
+		float energy = 2*bit-1.0;
+		energy *= energy;
 		if (energy < low) low = energy;
 		avg += energy/len;
 	}
@@ -285,12 +547,8 @@ 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.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 << "'";
+		if (sv[i]<0.25) os << "0";
+		else if (sv[i]>0.75) os << "1";
 		else os << "-";
 	}
 	return os;

CommonLibs/BitVector.h

@@ -30,6 +30,201 @@
 #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> {
 
 
@@ -87,6 +282,16 @@ 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();
@@ -222,20 +427,23 @@ class SoftVector: public Vector<float> {
 	const SoftVector tail(size_t start) const { return segment(start,size()-start); }
 	//@}
 
-	// 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
+	/** 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
 	// 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.0F); }
+	void unknown() { fill(0.5F); }
 
 	/** 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.0F;
+		return (*dp)>0.5F;
 	}
 
 	/** Slice the whole signal into bits. */

CommonLibs/BitVectorTest.cpp

@@ -35,6 +35,27 @@ 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);
@@ -49,6 +70,13 @@ 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/CMakeLists.txt

@@ -1,50 +0,0 @@
-#
-# Copyright 2008, 2009 Free Software Foundation, Inc.
-# Copyright 2011, 2012 Range Networks, Inc.
-#
-# This software is distributed under the terms of the GNU Public License.
-# See the COPYING file in the main directory for details.
-#
-# This program is free software: you can redistribute it and/or modify
-# it under the terms of the GNU General Public License as published by
-# the Free Software Foundation, either version 3 of the License, or
-# (at your option) any later version.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with this program.  If not, see <http://www.gnu.org/licenses/>.
-#
-
-set(EXTRA_DIST example.config README.common)
-
-set(libcommon_files
-	BitVector.cpp
-	LinkedLists.cpp
-	Sockets.cpp
-	Threads.cpp
-	Timeval.cpp
-	Logger.cpp)
-
-if(SQLITE_CONFIG)
-	set(libcommon_files
-		${libcommon_files}
-		Configuration.cpp
-		sqlite3util.cpp)
-endif(SQLITE_CONFIG)
-
-add_library(common ${libcommon_files})
-
-add_executable(InterthreadTest InterthreadTest.cpp)
-target_link_libraries(InterthreadTest common pthread)
-
-add_executable(SocketsTest SocketsTest.cpp)
-target_link_libraries(SocketsTest common pthread)
-
-add_executable(TimevalTest TimevalTest.cpp)
-target_link_libraries(TimevalTest common)
-
-

CommonLibs/Configuration.cpp

@@ -35,7 +35,7 @@
 #ifdef DEBUG_CONFIG
 #define	debugLogEarly gLogEarly
 #else
-#define	debugLogEarly(x,y,z)
+#define	debugLogEarly
 #endif
 
 
@@ -53,23 +53,6 @@ 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
@@ -113,7 +96,7 @@ ConfigurationTable::ConfigurationTable(const char* filename, const char *wCmdNam
 		"Maximum number of alarms to remember inside the application."
 	);
 	mSchema[tmp->getName()] = *tmp;
-	delete tmp;
+	free(tmp);
 
 	tmp = new ConfigurationKey("Log.File","",
 		"",
@@ -127,7 +110,7 @@ ConfigurationTable::ConfigurationTable(const char* filename, const char *wCmdNam
 			"To disable again, execute \"unconfig Log.File\"."
 	);
 	mSchema[tmp->getName()] = *tmp;
-	delete tmp;
+	free(tmp);
 
 	tmp = new ConfigurationKey("Log.Level","NOTICE",
 		"",
@@ -145,7 +128,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;
-	delete tmp;
+	free(tmp);
 
 	// Add application specific schema
 	mSchema.insert(wSchema.begin(), wSchema.end());
@@ -276,8 +259,8 @@ string ConfigurationTable::getTeX(const std::string& program, const std::string&
 	ss << "% END AUTO-GENERATED CONTENT" << endl;
 	ss << endl;
 
-	string tmp = replaceAll(ss.str(), "^", "\\^");
-	return replaceAll(tmp, "_", "\\_");
+	string tmp = Utils::replaceAll(ss.str(), "^", "\\^");
+	return Utils::replaceAll(tmp, "_", "\\_");
 }
 
 bool ConfigurationTable::defines(const string& key)

CommonLibs/ConfigurationTest.cpp

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

CommonLibs/F16.h

@@ -0,0 +1,210 @@
+/*
+* 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

@@ -0,0 +1,55 @@
+/*
+* 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,7 +30,6 @@
 #include <fstream>
 #include <string>
 #include <stdarg.h>
-#include <sys/time.h>	// For gettimeofday
 
 #include "Configuration.h"
 #include "Logger.h"
@@ -39,14 +38,6 @@
 
 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;
 
@@ -76,6 +67,10 @@ const char *levelNames[] = {
 	"EMERG", "ALERT", "CRIT", "ERR", "WARNING", "NOTICE", "INFO", "DEBUG"
 };
 int numLevels = 8;
+bool gLogToConsole = true;
+bool gLogToSyslog = false;
+FILE *gLogToFile = NULL;
+Mutex gLogToLock;
 
 
 int levelStringToInt(const string& name)
@@ -112,31 +107,6 @@ 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)
 {
@@ -299,32 +269,9 @@ void gLogInit(const char* name, const char* level, int facility)
 void gLogEarly(int level, const char *fmt, ...)
 {
 	va_list args;
-
+ 
 	va_start(args, fmt);
-
-	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);
-	}
-
+	vsyslog(level | LOG_USER, fmt, args);
 	va_end(args);
 }
 

CommonLibs/Logger.h

@@ -83,6 +83,7 @@
 
 
 #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.
@@ -122,8 +123,6 @@ 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,39 +36,49 @@ libcommon_la_SOURCES = \
 	Sockets.cpp \
 	Threads.cpp \
 	Timeval.cpp \
+	Reporting.cpp \
 	Logger.cpp \
 	Configuration.cpp \
-	sqlite3util.cpp
+	sqlite3util.cpp \
+	URLEncode.cpp \
+	Utils.cpp
 
 noinst_PROGRAMS = \
 	BitVectorTest \
-	PRBSTest \
 	InterthreadTest \
 	SocketsTest \
 	TimevalTest \
+	RegexpTest \
 	VectorTest \
 	ConfigurationTest \
-	LogTest
+	LogTest \
+	URLEncodeTest \
+	F16Test
 
 #	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
 
-BitVectorTest_SOURCES = BitVectorTest.cpp
-BitVectorTest_LDADD = libcommon.la $(SQLITE3_LIBS)
+URLEncodeTest_SOURCES = URLEncodeTest.cpp
+URLEncodeTest_LDADD = libcommon.la
 
-PRBSTest_SOURCES = PRBSTest.cpp
+BitVectorTest_SOURCES = BitVectorTest.cpp
+BitVectorTest_LDADD = libcommon.la $(SQLITE_LA)
 
 InterthreadTest_SOURCES = InterthreadTest.cpp
 InterthreadTest_LDADD = libcommon.la
@@ -82,16 +92,21 @@ TimevalTest_SOURCES = TimevalTest.cpp
 TimevalTest_LDADD = libcommon.la
 
 VectorTest_SOURCES = VectorTest.cpp
-VectorTest_LDADD = libcommon.la $(SQLITE3_LIBS)
+VectorTest_LDADD = libcommon.la $(SQLITE_LA)
+
+RegexpTest_SOURCES = RegexpTest.cpp
+RegexpTest_LDADD = libcommon.la
 
 ConfigurationTest_SOURCES = ConfigurationTest.cpp
-ConfigurationTest_LDADD = libcommon.la 	$(SQLITE3_LIBS)
+ConfigurationTest_LDADD = libcommon.la 	$(SQLITE_LA)
 
 # ReportingTest_SOURCES = ReportingTest.cpp
 # ReportingTest_LDADD = libcommon.la $(SQLITE_LA)
 
 LogTest_SOURCES = LogTest.cpp
-LogTest_LDADD = libcommon.la $(SQLITE3_LIBS)
+LogTest_LDADD = libcommon.la $(SQLITE_LA)
+
+F16Test_SOURCES = F16Test.cpp
 
 MOSTLYCLEANFILES += testSource testDestination
 

CommonLibs/MemoryLeak.h

@@ -0,0 +1,111 @@
+/*
+* 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

@@ -1,110 +0,0 @@
-/*
- * 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

@@ -1,42 +0,0 @@
-/*
- * 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

@@ -0,0 +1,64 @@
+/*
+* 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

@@ -0,0 +1,48 @@
+/*
+* 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

@@ -0,0 +1,145 @@
+/**@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

@@ -0,0 +1,86 @@
+/**@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

@@ -0,0 +1,136 @@
+/*
+* 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,20 +187,24 @@ int DatagramSocket::send(const struct sockaddr* dest, const char * message)
 	return send(dest,message,length);
 }
 
-int DatagramSocket::read(char* buffer, size_t length)
-{
-	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)) {
+
+
+
+int DatagramSocket::read(char* buffer)
+{
+	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)) {
 		perror("DatagramSocket::read() failed");
 		throw SocketError();
 	}
-	return rd_length;
+	return length;
 }
 
-int DatagramSocket::read(char* buffer, size_t length, unsigned timeout)
+
+int DatagramSocket::read(char* buffer, unsigned timeout)
 {
 	fd_set fds;
 	FD_ZERO(&fds);
@@ -214,7 +218,7 @@ int DatagramSocket::read(char* buffer, size_t length, unsigned timeout)
 		throw SocketError();
 	}
 	if (sel==0) return -1;
-	if (FD_ISSET(mSocketFD,&fds)) return read(buffer, length);
+	if (FD_ISSET(mSocketFD,&fds)) return read(buffer);
 	return -1;
 }
 
@@ -223,18 +227,18 @@ int DatagramSocket::read(char* buffer, size_t length, unsigned timeout)
 
 
 
-UDPSocket::UDPSocket(const char *wSrcIP, unsigned short wSrcPort)
+UDPSocket::UDPSocket(unsigned short wSrcPort)
 	:DatagramSocket()
 {
-	open(wSrcPort, wSrcIP);
+	open(wSrcPort);
 }
 
 
-UDPSocket::UDPSocket(const char *wSrcIP, unsigned short wSrcPort,
-		     const char *wDestIP, unsigned short wDestPort)
+UDPSocket::UDPSocket(unsigned short wSrcPort,
+          	 const char * wDestIP, unsigned short wDestPort )
 	:DatagramSocket()
 {
-	open(wSrcPort, wSrcIP);
+	open(wSrcPort);
 	destination(wDestPort, wDestIP);
 }
 
@@ -246,7 +250,7 @@ void UDPSocket::destination( unsigned short wDestPort, const char * wDestIP )
 }
 
 
-void UDPSocket::open(unsigned short localPort, const char *wlocalIP)
+void UDPSocket::open(unsigned short localPort)
 {
 	// create
 	mSocketFD = socket(AF_INET,SOCK_DGRAM,0);
@@ -265,7 +269,7 @@ void UDPSocket::open(unsigned short localPort, const char *wlocalIP)
 	size_t length = sizeof(address);
 	bzero(&address,length);
 	address.sin_family = AF_INET;
-	address.sin_addr.s_addr = inet_addr(wlocalIP);
+	address.sin_addr.s_addr = INADDR_ANY;
 	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, size_t length);
+	int read(char* buffer);
 
 	/**
 		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, size_t length, unsigned timeout);
+	int read(char* buffer, unsigned timeout);
 
 
 	/** Send a packet to a given destination, other than the default. */
@@ -144,11 +144,11 @@ class UDPSocket : public DatagramSocket {
 public:
 
 	/** Open a USP socket with an OS-assigned port and no default destination. */
-	UDPSocket(const char *localIP, unsigned short localPort);
+	UDPSocket( unsigned short localPort=0);
 
 	/** Given a full specification, open the socket and set the dest address. */
-	UDPSocket(const char *localIP, unsigned short localPort,
-		  const char *remoteIP, unsigned short remotePort);
+	UDPSocket( 	unsigned short localPort, 
+			const char * remoteIP, unsigned short remotePort);
 
 	/** Set the destination port. */
 	void destination( unsigned short wDestPort, const char * wDestIP );
@@ -157,7 +157,7 @@ public:
 	unsigned short port() const;
 
 	/** Open and bind the UDP socket to a local port. */
-	void open(unsigned short localPort=0, const char *wlocalIP="127.0.0.1");
+	void open(unsigned short localPort=0);
 
 	/** Give the return address of the most recently received packet. */
 	const struct sockaddr_in* source() const { return (const struct sockaddr_in*)mSource; }

CommonLibs/SocketsTest.cpp

@@ -37,12 +37,12 @@ static const int gNumToSend = 10;
 
 void *testReaderIP(void *)
 {
-	UDPSocket readSocket("127.0.0.1", 5934, "localhost", 5061);
+	UDPSocket readSocket(5934, "localhost", 5061);
 	readSocket.nonblocking();
 	int rc = 0;
 	while (rc<gNumToSend) {
 		char buf[MAX_UDP_LENGTH];
-		int count = readSocket.read(buf, MAX_UDP_LENGTH);
+		int count = readSocket.read(buf);
 		if (count>0) {
 			COUT("read: " << buf);
 			rc++;
@@ -61,9 +61,8 @@ void *testReaderUnix(void *)
 	readSocket.nonblocking();
 	int rc = 0;
 	while (rc<gNumToSend) {
-		char buf[MAX_UDP_LENGTH+1];
-		buf[MAX_UDP_LENGTH] =  '\0';
-		int count = readSocket.read(buf, MAX_UDP_LENGTH);
+		char buf[MAX_UDP_LENGTH];
+		int count = readSocket.read(buf);
 		if (count>0) {
 			COUT("read: " << buf);
 			rc++;
@@ -83,7 +82,7 @@ int main(int argc, char * argv[] )
   Thread readerThreadUnix;
   readerThreadUnix.start(testReaderUnix,NULL);
 
-  UDPSocket socket1("127.0.0.1", 5061, "127.0.0.1", 5934);
+  UDPSocket socket1(5061, "127.0.0.1",5934);
   UDDSocket socket1U("testSource","testDestination");
   
   COUT("socket1: " << socket1.port());

CommonLibs/URLEncode.cpp

@@ -0,0 +1,28 @@
+/* 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

@@ -0,0 +1,30 @@
+/*
+* 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

@@ -0,0 +1,17 @@
+
+#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

@@ -0,0 +1,211 @@
+/*
+* 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

@@ -0,0 +1,148 @@
+/*
+* 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,13 +92,6 @@ 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); }
 
@@ -118,8 +111,8 @@ template <class T> class Vector {
 	/** Build an empty Vector of a given size. */
 	Vector(size_t wSize=0):mData(NULL) { resize(wSize); }
 
-	/** Build a Vector by moving another. */
-	Vector(Vector<T>&& other)
+	/** Build a Vector by shifting the data block. */
+	Vector(Vector<T>& other)
 		:mData(other.mData),mStart(other.mStart),mEnd(other.mEnd)
 	{ other.mData=NULL; }
 
@@ -229,21 +222,6 @@ 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,24 +41,10 @@ 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");
 
-//                               |-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,12 @@ 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;
 
 
 /**@name Modulus operations for frame numbers. */

INSTALLATION

@@ -1 +1,33 @@
-This is special branch for XTRX support. It should be configured with cmake, autoconf isn't supported yet.
+Installation Requirements
+
+
+
+OpenBTS compiles to a simple Unix binary and does not require special
+installation.
+
+One some systems (Ubuntu), you will need to define LIBS = -lpthread prior to
+running configure.
+
+To run OpenBTS, the following should be installed:
+
+	Asterisk (http://www.asterisk.org), running SIP on port 5060.
+
+	libosip2 (http://www.gnu.org/software/osip/)
+
+	libortp (http://freshmeat.net/projects/ortp/)
+
+	libusrp (http://gnuradio.org).
+	This is part of the GNURadio installation.
+	It is the only part used by OpenBTS.
+
+
+OpenBTS logs to syslogd as facility LOG_LOCAL7.  Please set your /etc/syslog.conf
+accordingly.
+
+
+For information on specific executables, see tests/README.tests and
+apps/README.apps.
+
+See http://gnuradio.org/redmine/wiki/gnuradio/OpenBTS/BuildingAndRunning for more
+information.
+

Makefile.am

@@ -21,13 +21,14 @@
 include $(top_srcdir)/Makefile.common
 
 ACLOCAL_AMFLAGS = -I config
-AM_CPPFLAGS = $(STD_DEFINES_AND_INCLUDES) $(USB_INCLUDES) $(WITH_INCLUDES) $(SQLITE3_CFLAGS)
+AM_CPPFLAGS = $(STD_DEFINES_AND_INCLUDES) $(USB_INCLUDES) $(WITH_INCLUDES)
 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
@@ -39,7 +40,6 @@ EXTRA_DIST = \
 	COPYING \
 	README
 
-@RELMAKE@
 
 dox: FORCE
 	doxygen doxconfig

Makefile.common

@@ -23,13 +23,16 @@ 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$(GSM_INCLUDEDIR) \
+	-I$(SQLITE_INCLUDEDIR)
 
 COMMON_LA = $(top_builddir)/CommonLibs/libcommon.la
 GSM_LA = $(top_builddir)/GSM/libGSM.la
+SQLITE_LA = $(top_builddir)/sqlite3/libsqlite.la -ldl
 
 MOSTLYCLEANFILES = *~

Transceiver52M/CMakeLists.txt

@@ -1,67 +0,0 @@
-if(NOT TRANS_FULL_VERSION)
-    add_definitions(-DNO_RESAMPLER)
-    add_definitions(-DNO_MULTIARFCN)
-endif()
-
-
-add_subdirectory(x86)
-include_directories(common)
-include_directories(".")
-
-set(COMMON_FILES
-	radioInterface.cpp
-	radioVector.cpp
-	radioClock.cpp
-	radioBuffer.cpp
-	sigProcLib.cpp
-	signalVector.cpp
-	Transceiver.cpp)
-
-set(libtransceiver_files
-	Resampler.cpp
-	${COMMON_FILES})
-
-if(TRANS_FULL_VERSION)
-	set(libtransceiver_files
-		${libtransceiver_files}
-		radioInterfaceResamp.cpp
-		radioInterfaceMulti.cpp
-		ChannelizerBase.cpp
-		Channelizer.cpp
-		Synthesis.cpp
-		common/fft.c
-		radioInterfaceDiversity.cpp)
-endif(TRANS_FULL_VERSION)
-
-set(noinst_HEADERS
-	Complex.h
-	radioInterface.h
-	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/fft.h)
-
-add_library(transceiver ${libtransceiver_files})
-
-
-set(DEVICE        XTRXDevice.cpp)
-set(DEVICE_LIBS   ${XTRX_LIBRARIES})
-set(DEVICE_INC    ${XTRX_INCLUDES})
-
-include_directories(${DEVICE_INC})
-add_executable(osmo-trx osmo-trx.cpp ${DEVICE})
-target_link_libraries(osmo-trx transceiver arch GSM common ${sqlite3} ${FFTW_LIBRARIES} ${DEVICE_LIBS} pthread dl)
-

Transceiver52M/Channelizer.cpp

@@ -1,108 +0,0 @@
-/*
- * 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

@@ -1,34 +0,0 @@
-#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

@@ -1,251 +0,0 @@
-/*
- * 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

@@ -1,39 +0,0 @@
-#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${srcdir}/common
+AM_CPPFLAGS = -Wall $(STD_DEFINES_AND_INCLUDES) -I./common
 AM_CXXFLAGS = -ldl -lpthread
 
 SUBDIRS = arm x86
@@ -54,20 +54,15 @@ COMMON_SOURCES = \
 	radioInterface.cpp \
 	radioVector.cpp \
 	radioClock.cpp \
-	radioBuffer.cpp \
 	sigProcLib.cpp \
 	signalVector.cpp \
-	Transceiver.cpp \
-	ChannelizerBase.cpp \
-	Channelizer.cpp \
-	Synthesis.cpp \
-	common/fft.c
+	Transceiver.cpp
 
 libtransceiver_la_SOURCES = \
 	$(COMMON_SOURCES) \
 	Resampler.cpp \
 	radioInterfaceResamp.cpp \
-	radioInterfaceMulti.cpp
+	radioInterfaceDiversity.cpp
 
 bin_PROGRAMS = osmo-trx
 
@@ -77,32 +72,27 @@ 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/fft.h
+	common/mult.h
 
 osmo_trx_SOURCES = osmo-trx.cpp
 osmo_trx_LDADD = \
 	libtransceiver.la \
 	$(ARCH_LA) \
 	$(GSM_LA) \
-	$(COMMON_LA) $(SQLITE3_LIBS)
+	$(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) $(FFTWF_LIBS)
+osmo_trx_LDADD += $(UHD_LIBS)
 endif

Transceiver52M/Resampler.cpp

@@ -22,7 +22,6 @@
 #include <string.h>
 #include <malloc.h>
 #include <iostream>
-#include <algorithm>
 
 #include "Resampler.h"
 
@@ -36,8 +35,6 @@ extern "C" {
 
 #define MAX_OUTPUT_LEN		4096
 
-using namespace std;
-
 static float sinc(float x)
 {
 	if (x == 0.0)
@@ -46,19 +43,32 @@ static float sinc(float x)
 	return sin(M_PI * x) / (M_PI * x);
 }
 
-void Resampler::initFilters(float bw)
+bool Resampler::initFilters(float bw)
 {
-	float cutoff;
+	size_t proto_len = p * filt_len;
+	float *proto, val, cutoff;
 	float sum = 0.0f, scale = 0.0f;
+	float midpt = (float) (proto_len - 1.0) / 2.0;
 
 	/* 
 	 * Allocate partition filters and the temporary prototype filter
 	 * according to numerator of the rational rate. Coefficients are
 	 * real only and must be 16-byte memory aligned for SSE usage.
 	 */
-	auto proto = vector<float>(p * filt_len);
-	for (auto &part : partitions)
-		part = (complex<float> *) memalign(16, filt_len * sizeof(complex<float>));
+	proto = new float[proto_len];
+	if (!proto)
+		return false;
+
+	partitions = (float **) malloc(sizeof(float *) * p);
+	if (!partitions) {
+		free(proto);
+		return false;
+	}
+
+	for (size_t i = 0; i < p; i++) {
+		partitions[i] = (float *)
+				memalign(16, filt_len * 2 * sizeof(float));
+	}
 
 	/* 
 	 * Generate the prototype filter with a Blackman-harris window.
@@ -75,26 +85,47 @@ void Resampler::initFilters(float bw)
 	else
 		cutoff = (float) q;
 
-	float midpt = (proto.size() - 1) / 2.0;
-	for (size_t i = 0; i < proto.size(); i++) {
+	for (size_t i = 0; i < proto_len; i++) {
 		proto[i] = sinc(((float) i - midpt) / cutoff * bw);
 		proto[i] *= a0 -
-			    a1 * cos(2 * M_PI * i / (proto.size() - 1)) +
-			    a2 * cos(4 * M_PI * i / (proto.size() - 1)) -
-			    a3 * cos(6 * M_PI * i / (proto.size() - 1));
+			    a1 * cos(2 * M_PI * i / (proto_len - 1)) +
+			    a2 * cos(4 * M_PI * i / (proto_len - 1)) -
+			    a3 * cos(6 * M_PI * i / (proto_len - 1));
 		sum += proto[i];
 	}
 	scale = p / sum;
 
 	/* Populate filter partitions from the prototype filter */
 	for (size_t i = 0; i < filt_len; i++) {
-		for (size_t n = 0; n < p; n++)
-			partitions[n][i] = complex<float>(proto[i * p + n] * scale);
+		for (size_t n = 0; n < p; n++) {
+			partitions[n][2 * i + 0] = proto[i * p + n] * scale;
+			partitions[n][2 * i + 1] = 0.0f;
+		}
 	}
 
-	/* Store filter taps in reverse */
-	for (auto &part : partitions)
-		reverse(&part[0], &part[filt_len]);
+	/* For convolution, we store the filter taps in reverse */ 
+	for (size_t n = 0; n < p; n++) {
+		for (size_t i = 0; i < filt_len / 2; i++) {
+			val = partitions[n][2 * i];
+			partitions[n][2 * i] = partitions[n][2 * (filt_len - 1 - i)];
+			partitions[n][2 * (filt_len - 1 - i)] = val;
+		}
+	}
+
+	delete proto;
+
+	return true;
+}
+
+void Resampler::releaseFilters()
+{
+	if (partitions) {
+		for (size_t i = 0; i < p; i++)
+			free(partitions[i]);
+	}
+
+	free(partitions);
+	partitions = NULL;
 }
 
 static bool check_vec_len(int in_len, int out_len, int p, int q)
@@ -128,12 +159,24 @@ static bool check_vec_len(int in_len, int out_len, int p, int q)
 	return true;
 }
 
-int Resampler::rotate(const float *in, size_t in_len, float *out, size_t out_len)
+void Resampler::computePath()
+{
+	for (int i = 0; i < MAX_OUTPUT_LEN; i++) {
+		in_index[i] = (q * i) / p;
+		out_path[i] = (q * i) % p;
+	}
+}
+
+int Resampler::rotate(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;
+		return -1; 
+
+	/* Insert history */
+	memcpy(&in[-2 * hist_len], history, hist_len * 2 * sizeof(float));
 
 	/* Generate output from precomputed input/output paths */
 	for (size_t i = 0; i < out_len; i++) {
@@ -141,28 +184,34 @@ int Resampler::rotate(const float *in, size_t in_len, float *out, size_t out_len
 		path = out_path[i]; 
 
 		convolve_real(in, in_len,
-			      reinterpret_cast<float *>(partitions[path]),
-			      filt_len, &out[2 * i], out_len - i,
+			      partitions[path], filt_len,
+			      &out[2 * i], out_len - i,
 			      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)
 {
-	if (p == 0 || q == 0 || filt_len == 0) return false;
+	size_t hist_len = filt_len - 1;
 
 	/* Filterbank filter internals */
-	initFilters(bw);
+	if (initFilters(bw) < 0)
+		return false;
+
+	/* History buffer */
+	history = new float[2 * hist_len];
+	memset(history, 0, 2 * hist_len * sizeof(float));
 
 	/* Precompute filterbank paths */
-	int i = 0;
-	for (auto &index : in_index)
-		index = (q * i++) / p;
-	i = 0;
-	for (auto &path : out_path)
-		path = (q * i++) % p;
+	in_index = new size_t[MAX_OUTPUT_LEN];
+	out_path = new size_t[MAX_OUTPUT_LEN];
+	computePath();
 
 	return true;
 }
@@ -173,7 +222,7 @@ size_t Resampler::len()
 }
 
 Resampler::Resampler(size_t p, size_t q, size_t filt_len)
-	: in_index(MAX_OUTPUT_LEN), out_path(MAX_OUTPUT_LEN), partitions(p)
+	: in_index(NULL), out_path(NULL), partitions(NULL), history(NULL)
 {
 	this->p = p;
 	this->q = q;
@@ -182,6 +231,9 @@ Resampler::Resampler(size_t p, size_t q, size_t filt_len)
 
 Resampler::~Resampler()
 {
-	for (auto &part : partitions)
-		free(part);
+	releaseFilters();
+
+	delete history;
+	delete in_index;
+	delete out_path;
 }

Transceiver52M/Resampler.h

@@ -20,9 +20,6 @@
 #ifndef _RESAMPLER_H_
 #define _RESAMPLER_H_
 
-#include <vector>
-#include <complex>
-
 class Resampler {
 public:
 	/* Constructor for rational sample rate conversion
@@ -55,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(const float *in, size_t in_len, float *out, size_t out_len);
+	int rotate(float *in, size_t in_len, float *out, size_t out_len);
 
 	/* Get filter length
 	 *   @return number of taps in each filter partition 
@@ -66,11 +63,15 @@ private:
 	size_t p;
 	size_t q;
 	size_t filt_len;
-	std::vector<size_t> in_index;
-	std::vector<size_t> out_path;
-	std::vector<std::complex<float> *> partitions;
+	size_t *in_index;
+	size_t *out_path;
 
-	void initFilters(float bw);
+	float **partitions;
+	float *history;
+
+	bool initFilters(float bw);
+	void releaseFilters();
+	void computePath();
 };
 
 #endif /* _RESAMPLER_H_ */

Transceiver52M/Synthesis.cpp

@@ -1,121 +0,0 @@
-/*
- * 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

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

Transceiver52M/Transceiver.cpp

@@ -71,60 +71,88 @@ TransceiverState::~TransceiverState()
   }
 }
 
-bool TransceiverState::init(int filler, size_t sps, float scale, size_t rtsc, unsigned rach_delay)
+static BitVector *genRandNormalBurst(size_t tsc)
 {
+  if (tsc > 7)
+    return NULL;
+
+  BitVector *bits = new BitVector(148);
+
+  size_t i = 0;
+
+  /* Tail bits */
+  for (; i < 4; i++)
+    (*bits)[i] = 0;
+
+  /* Random bits */
+  for (; i < 61; i++)
+    (*bits)[i] = rand() % 2;
+
+  /* Training sequence */
+  for (int j = 0; i < 87; i++, j++)
+    (*bits)[i] = GSM::gTrainingSequence[tsc][j];
+
+  /* Random bits */
+  for (; i < 144; i++)
+    (*bits)[i] = rand() % 2;
+
+  /* Tail bits */
+  for (; i < 148; i++)
+    (*bits)[i] = 0;
+
+  return bits;
+}
+
+bool TransceiverState::init(int filler, size_t sps, float scale, size_t rtsc)
+{
+  BitVector *bits;
   signalVector *burst;
 
   if ((sps != 1) && (sps != 4))
     return false;
 
   for (size_t n = 0; n < 8; n++) {
+    size_t guard = 8 + !(n % 4);
+    size_t len = sps == 4 ? 625 : 148 + guard;
+
     for (size_t i = 0; i < 102; i++) {
       switch (filler) {
       case Transceiver::FILLER_DUMMY:
-        burst = generateDummyBurst(sps, n);
+        burst = modulateBurst(gDummyBurst, guard, sps);
         break;
-      case Transceiver::FILLER_NORM_RAND:
-        burst = genRandNormalBurst(rtsc, sps, n);
-        break;
-      case Transceiver::FILLER_EDGE_RAND:
-        burst = generateEdgeBurst(rtsc);
-        break;
-      case Transceiver::FILLER_ACCESS_RAND:
-        burst = genRandAccessBurst(rach_delay, sps, n);
+      case Transceiver::FILLER_RAND:
+        bits = genRandNormalBurst(rtsc);
+        burst = modulateBurst(*bits, guard, sps);
+        delete bits;
         break;
       case Transceiver::FILLER_ZERO:
       default:
-        burst = generateEmptyBurst(sps, n);
+        burst = new signalVector(len);
       }
 
       scaleVector(*burst, scale);
       fillerTable[i][n] = burst;
     }
 
-    if ((filler == Transceiver::FILLER_NORM_RAND) ||
-        (filler == Transceiver::FILLER_EDGE_RAND)) {
-        chanType[n] = TSC;
-    }
+    if (filler == Transceiver::FILLER_RAND)
+      chanType[n] = Transceiver::TSC;
   }
 
   return false;
 }
 
 Transceiver::Transceiver(int wBasePort,
-                         const char *TRXAddress,
-                         const char *GSMcoreAddress,
-                         size_t tx_sps, size_t rx_sps, size_t chans,
+                         const char *wTRXAddress,
+                         size_t wSPS, size_t wChans,
                          GSM::Time wTransmitLatency,
                          RadioInterface *wRadioInterface,
                          double wRssiOffset)
-  : mBasePort(wBasePort), mLocalAddr(TRXAddress), mRemoteAddr(GSMcoreAddress),
-    mClockSocket(TRXAddress, wBasePort, GSMcoreAddress, wBasePort + 100),
+  : mBasePort(wBasePort), mAddr(wTRXAddress),
+    mClockSocket(wBasePort, wTRXAddress, mBasePort + 100),
     mTransmitLatency(wTransmitLatency), mRadioInterface(wRadioInterface),
     rssiOffset(wRssiOffset),
-    mSPSTx(tx_sps), mSPSRx(rx_sps), mChans(chans), mEdge(false), mOn(false), mForceClockInterface(false),
-    mTxFreq(0.0), mRxFreq(0.0), mTSC(0), mMaxExpectedDelayAB(0), mMaxExpectedDelayNB(0),
-    mWriteBurstToDiskMask(0)
+    mSPSTx(wSPS), mSPSRx(1), mChans(wChans), mOn(false),
+    mTxFreq(0.0), mRxFreq(0.0), mTSC(0), mMaxExpectedDelay(0), mWriteBurstToDiskMask(0)
 {
   txFullScale = mRadioInterface->fullScaleInputValue();
   rxFullScale = mRadioInterface->fullScaleOutputValue();
@@ -161,7 +189,7 @@ Transceiver::~Transceiver()
  * are still expected to report clock indications through control channel
  * activity.
  */
-bool Transceiver::init(int filler, size_t rtsc, unsigned rach_delay, bool edge)
+bool Transceiver::init(int filler, size_t rtsc)
 {
   int d_srcport, d_dstport, c_srcport, c_dstport;
 
@@ -170,13 +198,11 @@ bool Transceiver::init(int filler, size_t rtsc, unsigned rach_delay, bool edge)
     return false;
   }
 
-  if (!sigProcLibSetup()) {
+  if (!sigProcLibSetup(mSPSTx)) {
     LOG(ALERT) << "Failed to initialize signal processing library";
     return false;
   }
 
-  mEdge = edge;
-
   mDataSockets.resize(mChans);
   mCtrlSockets.resize(mChans);
   mControlServiceLoopThreads.resize(mChans);
@@ -198,8 +224,8 @@ bool Transceiver::init(int filler, size_t rtsc, unsigned rach_delay, bool edge)
     d_srcport = mBasePort + 2 * i + 2;
     d_dstport = mBasePort + 2 * i + 102;
 
-    mCtrlSockets[i] = new UDPSocket(mLocalAddr.c_str(), c_srcport, mRemoteAddr.c_str(), c_dstport);
-    mDataSockets[i] = new UDPSocket(mLocalAddr.c_str(), d_srcport, mRemoteAddr.c_str(), d_dstport);
+    mCtrlSockets[i] = new UDPSocket(c_srcport, mAddr.c_str(), c_dstport);
+    mDataSockets[i] = new UDPSocket(d_srcport, mAddr.c_str(), d_dstport);
   }
 
   /* Randomize the central clock */
@@ -219,7 +245,7 @@ bool Transceiver::init(int filler, size_t rtsc, unsigned rach_delay, bool edge)
     if (i && filler == FILLER_DUMMY)
       filler = FILLER_ZERO;
 
-    mStates[i].init(filler, mSPSTx, txFullScale, rtsc, rach_delay);
+    mStates[i].init(filler, mSPSTx, txFullScale, rtsc);
   }
 
   return true;
@@ -274,7 +300,7 @@ bool Transceiver::start()
                             TxUpperLoopAdapter, (void*) chan);
   }
 
-  mForceClockInterface = true;
+  writeClockInterface();
   mOn = true;
   return true;
 }
@@ -298,10 +324,6 @@ void Transceiver::stop()
   LOG(NOTICE) << "Stopping the transceiver";
   mTxLowerLoopThread->cancel();
   mRxLowerLoopThread->cancel();
-  mTxLowerLoopThread->join();
-  mRxLowerLoopThread->join();
-  delete mTxLowerLoopThread;
-  delete mRxLowerLoopThread;
 
   for (size_t i = 0; i < mChans; i++) {
     mRxServiceLoopThreads[i]->cancel();
@@ -320,6 +342,11 @@ void Transceiver::stop()
     mTxPriorityQueues[i].clear();
   }
 
+  mTxLowerLoopThread->join();
+  mRxLowerLoopThread->join();
+  delete mTxLowerLoopThread;
+  delete mRxLowerLoopThread;
+
   mOn = false;
   LOG(NOTICE) << "Transceiver stopped";
 }
@@ -340,12 +367,7 @@ void Transceiver::addRadioVector(size_t chan, BitVector &bits,
     return;
   }
 
-  /* Use the number of bits as the EDGE burst indicator */
-  if (bits.size() == EDGE_BURST_NBITS)
-    burst = modulateEdgeBurst(bits, mSPSTx);
-  else
-    burst = modulateBurst(bits, 8 + (wTime.TN() % 4 == 0), mSPSTx);
-
+  burst = modulateBurst(bits, 8 + (wTime.TN() % 4 == 0), mSPSTx);
   scaleVector(*burst, txFullScale * pow(10, -RSSI / 10));
 
   radio_burst = new radioVector(wTime, burst);
@@ -430,7 +452,7 @@ void Transceiver::setModulus(size_t timeslot, size_t chan)
   case V:
     state->fillerModulus[timeslot] = 51;
     break;
-    //case V:
+    //case V: 
   case VII:
     state->fillerModulus[timeslot] = 102;
     break;
@@ -443,8 +465,8 @@ void Transceiver::setModulus(size_t timeslot, size_t chan)
 }
 
 
-CorrType Transceiver::expectedCorrType(GSM::Time currTime,
-                                       size_t chan)
+Transceiver::CorrType Transceiver::expectedCorrType(GSM::Time currTime,
+                                                    size_t chan)
 {
   static int tchh_subslot[26] = { 0,1,0,1,0,1,0,1,0,1,0,1,0,0,1,0,1,0,1,0,1,0,1,0,1,1 };
   static int sdcch4_subslot[102] = { 3,3,3,3,0,0,2,2,2,2,3,3,3,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0,2,2,2,2,
@@ -533,27 +555,140 @@ CorrType Transceiver::expectedCorrType(GSM::Time currTime,
   }
 }
 
-void writeToFile(radioVector *radio_burst, size_t chan)
+/* 
+ * Detect RACH synchronization sequence within a burst. No equalization
+ * is used or available on the RACH channel.
+ */
+int Transceiver::detectRACH(TransceiverState *state,
+                            signalVector &burst,
+                            complex &amp, float &toa)
+{
+  float threshold = 6.0;
+
+  return detectRACHBurst(burst, threshold, mSPSRx, amp, toa);
+}
+
+/*
+ * Detect normal burst training sequence midamble. Update equalization
+ * state information and channel estimate if necessary. Equalization
+ * is currently disabled.
+ */
+int Transceiver::detectTSC(TransceiverState *state, signalVector &burst,
+                           complex &amp, float &toa, GSM::Time &time)
+{
+  int success;
+  int tn = time.TN();
+  float chanOffset, threshold = 5.0;
+  bool needDFE = false, estimateChan = false;
+  double elapsed = time - state->chanEstimateTime[tn];
+  signalVector *chanResp;
+
+  /* Check equalization update state */
+  if (needDFE && ((elapsed > 50) || (!state->chanResponse[tn]))) {
+    delete state->DFEForward[tn];
+    delete state->DFEFeedback[tn];
+    state->DFEForward[tn] = NULL;
+    state->DFEFeedback[tn] = NULL;
+
+    estimateChan = true;
+  }
+
+  /* Detect normal burst midambles */
+  success = analyzeTrafficBurst(burst, mTSC, threshold, mSPSRx, amp,
+                                toa, mMaxExpectedDelay, estimateChan,
+                                &chanResp, &chanOffset);
+  if (success <= 0) {
+    return success;
+  }
+
+  /* Set equalizer if unabled */
+  if (needDFE && estimateChan) {
+     float noise = state->mNoiseLev;
+     state->SNRestimate[tn] = amp.norm2() / (noise * noise + 1.0);
+
+     state->chanResponse[tn] = chanResp;
+     state->chanRespOffset[tn] = chanOffset;
+     state->chanRespAmplitude[tn] = amp;
+
+     scaleVector(*chanResp, complex(1.0, 0.0) / amp);
+
+     designDFE(*chanResp, state->SNRestimate[tn],
+               7, &state->DFEForward[tn], &state->DFEFeedback[tn]);
+
+     state->chanEstimateTime[tn] = time;
+  }
+
+  return 1;
+}
+
+void writeToFile(signalVector *burst, const GSM::Time &time, size_t chan, const std::string postfix="")
 {
-  GSM::Time time = radio_burst->getTime();
   std::ostringstream fname;
-  fname << chan << "_" << time.FN() << "_" << time.TN() << ".fc";
-  std::ofstream outfile (fname.str().c_str(), std::ofstream::binary);
-  outfile.write((char*)radio_burst->getVector()->begin(), radio_burst->getVector()->size() * 2 * sizeof(float));
+  fname << chan << "_" << time.FN() << "_" << time.TN() << postfix << ".fc";
+  std::ofstream outfile(fname.str().c_str(), std::ofstream::binary);
+  outfile.write((char*)burst->begin(), burst->size() * 2 * sizeof(float));
   outfile.close();
 }
 
+/*
+ * Demodulate GMSK burst using equalization if requested. Otherwise
+ * demodulate by direct rotation and soft slicing.
+ */
+SoftVector *Transceiver::demodulate(TransceiverState *state,
+                                    signalVector &burst, complex amp,
+                                    float toa, size_t tn, bool equalize,
+                                    GSM::Time &wTime, size_t chan,
+                                    Transceiver::BurstQuality *qual)
+{
+  signalVector *aligned, *bit_aligned=NULL;
+  SoftVector *bits;
+
+  if (equalize) {
+    scaleVector(burst, complex(1.0, 0.0) / amp);
+    return equalizeBurst(burst,
+                         toa - state->chanRespOffset[tn],
+                         mSPSRx,
+                         *state->DFEForward[tn],
+                         *state->DFEFeedback[tn]);
+  }
+
+  aligned = alignBurst(burst, amp, toa);
+
+  if (qual) {
+    /* "aligned" burst has samples exactly between bits.
+     * Delay it by 1/2 bit more to get samples aligned to bit positions. */
+    bit_aligned = delayVector(aligned, NULL, 0.5);
+
+    /* Debug: dump bursts to disk */
+    if (needWriteBurstToDisk(wTime, chan))
+      writeToFile(bit_aligned, wTime, chan, "_aligned");
+  }
+
+  bits = demodulateBurst(*aligned, mSPSRx);
+
+  if (qual) {
+    /* Estimate signal quality */
+    estimateBurstQuality(bits->segment(0, gSlotLen).sliced(), bit_aligned, wTime, chan, *qual);
+    delete bit_aligned;
+  }
+
+  delete aligned;
+  return bits;
+}
+
 /*
  * Pull bursts from the FIFO and handle according to the slot
- * and burst correlation type. Equalzation is currently disabled.
+ * and burst correlation type. Equalzation is currently disabled. 
  */
 SoftVector *Transceiver::pullRadioVector(GSM::Time &wTime, double &RSSI, bool &isRssiValid,
                                          double &timingOffset, double &noise,
-                                         size_t chan)
+                                         size_t chan,
+                                         Transceiver::BurstQuality *qual)
 {
-  int rc;
+  int success;
+  bool equalize = false;
   complex amp;
-  float toa, max = -1.0, avg = 0.0;
+  float toa, pow, max = -1.0, avg = 0.0;
   int max_i = -1;
   signalVector *burst;
   SoftVector *bits = NULL;
@@ -569,15 +704,9 @@ SoftVector *Transceiver::pullRadioVector(GSM::Time &wTime, double &RSSI, bool &i
   GSM::Time time = radio_burst->getTime();
   CorrType type = expectedCorrType(time, chan);
 
-  /* Enable 8-PSK burst detection if EDGE is enabled */
-  if (mEdge && (type == TSC))
-    type = EDGE;
-
   /* Debug: dump bursts to disk */
-  /* bits 0-7  - chan 0 timeslots
-   * bits 8-15 - chan 1 timeslots */
-  if (mWriteBurstToDiskMask & ((1<<time.TN()) << (8*chan)))
-    writeToFile(radio_burst, chan);
+  if (needWriteBurstToDisk(time, chan))
+    writeToFile(radio_burst->getVector(), time, chan);
 
   /* No processing if the timeslot is off.
    * Not even power level or noise calculation. */
@@ -588,7 +717,7 @@ SoftVector *Transceiver::pullRadioVector(GSM::Time &wTime, double &RSSI, bool &i
 
   /* Select the diversity channel with highest energy */
   for (size_t i = 0; i < radio_burst->chans(); i++) {
-    float pow = energyDetect(*radio_burst->getVector(i), 20 * mSPSRx);
+    energyDetect(*radio_burst->getVector(i), 20 * mSPSRx, 0.0, &pow);
     if (pow > max) {
       max = pow;
       max_i = i;
@@ -626,15 +755,16 @@ SoftVector *Transceiver::pullRadioVector(GSM::Time &wTime, double &RSSI, bool &i
   }
 
   /* Detect normal or RACH bursts */
-  rc = detectAnyBurst(*burst, mTSC, BURST_THRESH, mSPSRx, type, amp, toa,
-                      (type==RACH)?mMaxExpectedDelayAB:mMaxExpectedDelayNB);
+  if (type == TSC)
+    success = detectTSC(state, *burst, amp, toa, time);
+  else
+    success = detectRACH(state, *burst, amp, toa);
 
-  if (rc > 0) {
-    type = (CorrType) rc;
-  } else if (rc <= 0) {
-    if (rc == -SIGERR_CLIP) {
+  /* Alert an error and exit */
+  if (success <= 0) {
+    if (success == -SIGERR_CLIP) {
       LOG(WARNING) << "Clipping detected on received RACH or Normal Burst";
-    } else if (rc != SIGERR_NONE) {
+    } else if (success != SIGERR_NONE) {
       LOG(WARNING) << "Unhandled RACH or Normal Burst detection error";
     }
 
@@ -642,9 +772,13 @@ SoftVector *Transceiver::pullRadioVector(GSM::Time &wTime, double &RSSI, bool &i
     return NULL;
   }
 
-  timingOffset = toa;
+  timingOffset = toa / mSPSRx;
 
-  bits = demodAnyBurst(*burst, mSPSRx, amp, toa, type);
+  /* Demodulate and set output info */
+  if (equalize && (type != TSC))
+    equalize = false;
+
+  bits = demodulate(state, *burst, amp, toa, time.TN(), equalize, time, chan, qual);
 
   delete radio_burst;
   return bits;
@@ -656,7 +790,7 @@ void Transceiver::reset()
     mTxPriorityQueues[i].clear();
 }
 
-
+  
 void Transceiver::driveControl(size_t chan)
 {
   int MAX_PACKET_LENGTH = 100;
@@ -666,7 +800,7 @@ void Transceiver::driveControl(size_t chan)
   int msgLen = -1;
   buffer[0] = '\0';
 
-  msgLen = mCtrlSockets[chan]->read(buffer, sizeof(buffer));
+  msgLen = mCtrlSockets[chan]->read(buffer);
 
   if (msgLen < 1) {
     return;
@@ -678,6 +812,9 @@ void Transceiver::driveControl(size_t chan)
 
   sscanf(buffer,"%3s %s",cmdcheck,command);
 
+  if (!chan)
+    writeClockInterface();
+
   if (strcmp(cmdcheck,"CMD")!=0) {
     LOG(WARNING) << "bogus message on control interface";
     return;
@@ -689,42 +826,36 @@ void Transceiver::driveControl(size_t chan)
     sprintf(response,"RSP POWEROFF 0");
   }
   else if (strcmp(command,"POWERON")==0) {
-    if (!start()) {
+    if (!start())
       sprintf(response,"RSP POWERON 1");
-    } else {
+    else
       sprintf(response,"RSP POWERON 0");
       for (int i = 0; i < 8; i++) {
         for (int j = 0; j < 8; j++)
           mHandover[i][j] = false;
       }
-    }
   }
   else if (strcmp(command,"HANDOVER")==0){
     int ts=0,ss=0;
     sscanf(buffer,"%3s %s %d %d",cmdcheck,command,&ts,&ss);
     mHandover[ts][ss] = true;
+    LOG(WARNING) << "HANDOVER RACH at timeslot " << ts << " subslot " << ss;
     sprintf(response,"RSP HANDOVER 0 %d %d",ts,ss);
   }
   else if (strcmp(command,"NOHANDOVER")==0){
     int ts=0,ss=0;
     sscanf(buffer,"%3s %s %d %d",cmdcheck,command,&ts,&ss);
     mHandover[ts][ss] = false;
+    LOG(WARNING) << "NOHANDOVER at timeslot " << ts << " subslot " << ss;
     sprintf(response,"RSP NOHANDOVER 0 %d %d",ts,ss);
   }
   else if (strcmp(command,"SETMAXDLY")==0) {
     //set expected maximum time-of-arrival
     int maxDelay;
     sscanf(buffer,"%3s %s %d",cmdcheck,command,&maxDelay);
-    mMaxExpectedDelayAB = maxDelay; // 1 GSM symbol is approx. 1 km
+    mMaxExpectedDelay = maxDelay; // 1 GSM symbol is approx. 1 km
     sprintf(response,"RSP SETMAXDLY 0 %d",maxDelay);
   }
-  else if (strcmp(command,"SETMAXDLYNB")==0) {
-    //set expected maximum time-of-arrival
-    int maxDelay;
-    sscanf(buffer,"%3s %s %d",cmdcheck,command,&maxDelay);
-    mMaxExpectedDelayNB = maxDelay; // 1 GSM symbol is approx. 1 km
-    sprintf(response,"RSP SETMAXDLYNB 0 %d",maxDelay);
-  }
   else if (strcmp(command,"SETRXGAIN")==0) {
     //set expected maximum time-of-arrival
     int newGain;
@@ -785,11 +916,13 @@ void Transceiver::driveControl(size_t chan)
     // set TSC
     unsigned TSC;
     sscanf(buffer, "%3s %s %d", cmdcheck, command, &TSC);
-    if (TSC > 7) {
+    if (mOn || (TSC < 0) || (TSC > 7))
       sprintf(response, "RSP SETTSC 1 %d", TSC);
-    } else {
-      LOG(NOTICE) << "Changing TSC from " << mTSC << " to " << TSC;
+    else if (chan && (TSC != mTSC))
+      sprintf(response, "RSP SETTSC 1 %d", TSC);
+    else {
       mTSC = TSC;
+      generateMidamble(mSPSRx, TSC);
       sprintf(response,"RSP SETTSC 0 %d", TSC);
     }
   }
@@ -802,7 +935,7 @@ void Transceiver::driveControl(size_t chan)
       LOG(WARNING) << "bogus message on control interface";
       sprintf(response,"RSP SETSLOT 1 %d %d",timeslot,corrCode);
       return;
-    }
+    }     
     mStates[chan].chanType[timeslot] = (ChannelCombination) corrCode;
     setModulus(timeslot, chan);
     sprintf(response,"RSP SETSLOT 0 %d %d",timeslot,corrCode);
@@ -826,20 +959,12 @@ void Transceiver::driveControl(size_t chan)
 
 bool Transceiver::driveTxPriorityQueue(size_t chan)
 {
-  int burstLen;
-  char buffer[EDGE_BURST_NBITS + 50];
+  char buffer[gSlotLen+50];
 
   // check data socket
-  size_t msgLen = mDataSockets[chan]->read(buffer, sizeof(buffer));
+  size_t msgLen = mDataSockets[chan]->read(buffer);
 
-  if (msgLen == gSlotLen + 1 + 4 + 1) {
-    burstLen = gSlotLen;
-  } else if (msgLen == EDGE_BURST_NBITS + 1 + 4 + 1) {
-    if (mSPSTx != 4)
-      return false;
-
-    burstLen = EDGE_BURST_NBITS;
-  } else {
+  if (msgLen!=gSlotLen+1+4+1) {
     LOG(ERR) << "badly formatted packet on GSM->TRX interface";
     return false;
   }
@@ -850,14 +975,14 @@ bool Transceiver::driveTxPriorityQueue(size_t chan)
     frameNum = (frameNum << 8) | (0x0ff & buffer[i+1]);
 
   LOG(DEBUG) << "rcvd. burst at: " << GSM::Time(frameNum,timeSlot);
-
+  
   int RSSI = (int) buffer[5];
-  BitVector newBurst(burstLen);
+  static BitVector newBurst(gSlotLen);
   BitVector::iterator itr = newBurst.begin();
   char *bufferItr = buffer+6;
-  while (itr < newBurst.end())
+  while (itr < newBurst.end()) 
     *itr++ = *bufferItr++;
-
+  
   GSM::Time currTime = GSM::Time(frameNum,timeSlot);
 
   addRadioVector(chan, newBurst, RSSI, currTime);
@@ -871,24 +996,129 @@ void Transceiver::driveReceiveRadio()
 {
   if (!mRadioInterface->driveReceiveRadio()) {
     usleep(100000);
-  } else if (mForceClockInterface || mTransmitDeadlineClock > mLastClockUpdateTime + GSM::Time(216,0)) {
-    mForceClockInterface = false;
-    writeClockInterface();
+  } else {
+    if (mTransmitDeadlineClock > mLastClockUpdateTime + GSM::Time(216,0))
+      writeClockInterface();
   }
 }
 
-void Transceiver::logRxBurst(size_t chan, SoftVector *burst, GSM::Time time, double dbm,
-                             double rssi, double noise, double toa)
+inline float wrapAngle2Pi(float angle)
 {
-  LOG(DEBUG) << std::fixed << std::right
-    << " chan: "   << chan
-    << " time: "   << time
-    << " RSSI: "   << std::setw(5) << std::setprecision(1) << rssi
-                   << "dBFS/" << std::setw(6) << -dbm << "dBm"
-    << " noise: "  << std::setw(5) << std::setprecision(1) << noise
-                   << "dBFS/" << std::setw(6) << -(noise + rssiOffset) << "dBm"
-    << " TOA: "    << std::setw(5) << std::setprecision(2) << toa
-    << " bits: "   << *burst;
+  const float twoPi = 2.0 * M_PI;
+  return angle - twoPi * floor( angle / twoPi );
+}
+
+inline float wrapAnglePi(float angle)
+{
+  const float twoPi = 2.0 * M_PI;
+  return angle - twoPi * floor( (angle+M_PI) / twoPi);
+}
+
+inline float rad2deg(float rad)
+{
+  return rad*180/M_PI;
+}
+
+inline int vectorMaxAbs(const Vector<float> &vec)
+{
+  int max_idx = 0;
+  float max = 0.0;
+  for (size_t i=1; i<vec.size(); i++) {
+    if (fabs(vec[i]) > max) {
+      max_idx = i;
+      max = fabs(vec[i]);
+    }
+  }
+  return max_idx;
+}
+
+inline float vectorRMS(const Vector<float> &vec)
+{
+  float rms = 0;
+  for (size_t i=1; i<vec.size(); i++) {
+    rms += vec[i]*vec[i];
+  }
+  return sqrt(rms/vec.size());
+}
+
+bool vectorLinearFit(const Vector<float> &y, float &slope, float &interceptor)
+{
+  int len_y = y.size();
+  float numerator = 0.0;
+  float denominator = 0.0;
+  float avg_x = len_y/2.0;
+  float avg_y = 0.0;
+
+  if (len_y==0)
+    return false;
+
+  for (int i=0; i<len_y; i++)
+    avg_y += y[i];
+  avg_y /= len_y;
+
+  for (int i=0; i<len_y; i++) {
+    numerator += (i - avg_x) * (y[i] - avg_y);
+    denominator += (i - avg_x) * (i - avg_x);
+  }
+
+  if (denominator == 0.0)
+    return false;
+
+  slope = numerator/denominator;
+  interceptor = avg_y - avg_x*slope;
+
+  return true;
+}
+
+void Transceiver::estimateBurstQuality(const BitVector &wBits, signalVector *received,
+                                       const GSM::Time &wTime, size_t chan,
+                                       Transceiver::BurstQuality &qual)
+{
+  signalVector *burst;
+  float slope, interceptor;
+
+  // this code supports only 4 SPS modulation
+  // we also assume that received vector is 1 SPS
+  assert(mSPSTx==4);
+
+  burst = modulateBurst(wBits, 8 + (wTime.TN() % 4 == 0), mSPSTx);
+
+  /* Debug: dump bursts to disk */
+  if (needWriteBurstToDisk(wTime, chan))
+    writeToFile(burst, wTime, chan, "_demod");
+
+  // flip values to align modulated format with the received format
+  for (size_t i=0; i<burst->size(); i++) {
+      (*burst)[i] = complex((*burst)[i].imag(), -(*burst)[i].real());
+  }
+
+  // calculate phase error for each bit
+  for (size_t i=0; i<qual.phase_err.size(); i++) {
+    float rx_phase = (*received)[i].arg();
+    // modulated data is 4SPS and is 1/4 bit shifted
+    float mod_phase = (*burst)[1+(2+i)*4].arg();
+    qual.phase_err[i] = wrapAnglePi(rx_phase - mod_phase);
+    qual.phase_err_deg[i] = rad2deg(qual.phase_err[i]);
+  }
+
+  // compensate for frequency error
+  if (vectorLinearFit(qual.phase_err, slope, interceptor)) {
+    for (size_t i=0; i<qual.phase_err.size(); i++) {
+      qual.phase_err[i] -= i*slope + interceptor;
+    }
+  }
+
+  // convert to degrees
+  for (size_t i=0; i<qual.phase_err.size(); i++) {
+    qual.phase_err_deg[i] = rad2deg(qual.phase_err[i]);
+  }
+
+  // calculate Peak and RMS values
+  qual.phase_err_max_idx = vectorMaxAbs(qual.phase_err);
+  qual.phase_err_max = qual.phase_err[qual.phase_err_max_idx];
+  qual.phase_err_rms = vectorRMS(qual.phase_err);
+
+  delete burst;
 }
 
 void Transceiver::driveReceiveFIFO(size_t chan)
@@ -901,49 +1131,50 @@ void Transceiver::driveReceiveFIFO(size_t chan)
   double noise; // noise level in dBFS
   GSM::Time burstTime;
   bool isRssiValid; // are RSSI, noise and burstTime valid
-  unsigned nbits = gSlotLen;
+  Transceiver::BurstQuality qual;
 
-  rxBurst = pullRadioVector(burstTime, RSSI, isRssiValid, TOA, noise, chan);
-  if (!rxBurst)
-    return;
+  rxBurst = pullRadioVector(burstTime, RSSI, isRssiValid, TOA, noise, chan, &qual);
 
-  // Convert -1..+1 soft bits to 0..1 soft bits
-  vectorSlicer(rxBurst);
+  if (rxBurst) { 
+    dBm = RSSI+rssiOffset;
+    TOAint = (int) (TOA * 256.0 + 0.5); // round to closest integer
 
-  /*
-   * EDGE demodulator returns 444 (148 * 3) bits
-   */
-  if (rxBurst->size() == gSlotLen * 3)
-    nbits = gSlotLen * 3;
+    LOG(INFO) << std::fixed << std::right
+      << " time: "   << burstTime
+      << " RSSI: "   << std::setw(5) << std::setprecision(1) << RSSI << "dBFS/" << std::setw(6) << -dBm << "dBm"
+      << " noise: "  << std::setw(5) << std::setprecision(1) << noise << "dBFS/" << std::setw(6) << -(noise+rssiOffset) << "dBm"
+      << " TOA: "    << std::setw(5) << std::setprecision(2) << TOA
+      << " peak: "   << std::setw(6) << std::setprecision(1) << qual.phase_err_deg[qual.phase_err_max_idx]
+//      << " @bit "    << std::setw(3) << qual.phase_err_max_idx
+      << " RMS: "    << std::setw(6) << std::setprecision(1) << rad2deg(qual.phase_err_rms)
+//      << " bits: " << std::setw(5) << std::setprecision(1) << qual.phase_err_deg
+//      << " energy: " << std::setw(5) << std::setprecision(2) << rxBurst->getEnergy()
+      << " bits: "   << *rxBurst;
 
-  dBm = RSSI + rssiOffset;
-  logRxBurst(chan, rxBurst, burstTime, dBm, RSSI, noise, TOA);
+    char burstString[gSlotLen+10];
+    burstString[0] = burstTime.TN();
+    for (int i = 0; i < 4; i++)
+      burstString[1+i] = (burstTime.FN() >> ((3-i)*8)) & 0x0ff;
+    burstString[5] = (int)dBm;
+    burstString[6] = (TOAint >> 8) & 0x0ff;
+    burstString[7] = TOAint & 0x0ff;
+    SoftVector::iterator burstItr = rxBurst->begin();
 
-  TOAint = (int) (TOA * 256.0 + 0.5); // round to closest integer
+    for (unsigned int i = 0; i < gSlotLen; i++) {
+      burstString[8+i] =(char) round((*burstItr++)*255.0);
+    }
+    burstString[gSlotLen+9] = '\0';
+    delete rxBurst;
 
-  char burstString[nbits + 10];
-  burstString[0] = burstTime.TN();
-  for (int i = 0; i < 4; i++)
-    burstString[1+i] = (burstTime.FN() >> ((3-i)*8)) & 0x0ff;
-  burstString[5] = (int)dBm;
-  burstString[6] = (TOAint >> 8) & 0x0ff;
-  burstString[7] = TOAint & 0x0ff;
-  SoftVector::iterator burstItr = rxBurst->begin();
-
-  for (unsigned i = 0; i < nbits; i++)
-    burstString[8 + i] = (char) round((*burstItr++) * 255.0);
-
-  burstString[nbits + 9] = '\0';
-  delete rxBurst;
-
-  mDataSockets[chan]->write(burstString, nbits + 10);
+    mDataSockets[chan]->write(burstString,gSlotLen+10);
+  }
 }
 
 void Transceiver::driveTxFIFO()
 {
 
   /**
-      Features a carefully controlled latency mechanism, to
+      Features a carefully controlled latency mechanism, to 
       assure that transmit packets arrive at the radio/USRP
       before they need to be transmitted.
 
@@ -954,7 +1185,7 @@ void Transceiver::driveTxFIFO()
 
 
   RadioClock *radioClock = (mRadioInterface->getClock());
-
+  
   if (mOn) {
     //radioClock->wait(); // wait until clock updates
     LOG(DEBUG) << "radio clock " << radioClock->get();

Transceiver52M/Transceiver.h

@@ -54,7 +54,7 @@ struct TransceiverState {
   ~TransceiverState();
 
   /* Initialize a multiframe slot in the filler table */
-  bool init(int filler, size_t sps, float scale, size_t rtsc, unsigned rach_delay);
+  bool init(int filler, size_t sps, float scale, size_t rtsc);
 
   int chanType[8];
 
@@ -89,18 +89,16 @@ struct TransceiverState {
 /** The Transceiver class, responsible for physical layer of basestation */
 class Transceiver {
 public:
-  /** Transceiver constructor
+  /** Transceiver constructor 
       @param wBasePort base port number of UDP sockets
-      @param TRXAddress IP address of the TRX, as a string
-      @param GSMcoreAddress IP address of the GSM core, as a string
+      @param TRXAddress IP address of the TRX manager, as a string
       @param wSPS number of samples per GSM symbol
       @param wTransmitLatency initial setting of transmit latency
       @param radioInterface associated radioInterface object
   */
   Transceiver(int wBasePort,
               const char *TRXAddress,
-              const char *GSMcoreAddress,
-              size_t tx_sps, size_t rx_sps, size_t chans,
+              size_t wSPS, size_t chans,
               GSM::Time wTransmitLatency,
               RadioInterface *wRadioInterface,
               double wRssiOffset);
@@ -109,7 +107,7 @@ public:
   ~Transceiver();
 
   /** Start the control loop */
-  bool init(int filler, size_t rtsc, unsigned rach_delay, bool edge);
+  bool init(int filler, size_t rtsc);
 
   /** attach the radioInterface receive FIFO */
   bool receiveFIFO(VectorFIFO *wFIFO, size_t chan)
@@ -144,18 +142,37 @@ public:
     LOOPBACK            ///< similar go VII, used in loopback testing
   } ChannelCombination;
 
+  /** Codes for burst types of received bursts*/
+  typedef enum {
+    OFF,               ///< timeslot is off
+    TSC,	       ///< timeslot should contain a normal burst
+    RACH,	       ///< timeslot should contain an access burst
+    IDLE	       ///< timeslot is an idle (or dummy) burst
+  } CorrType;
+
   enum FillerType {
     FILLER_DUMMY,
     FILLER_ZERO,
-    FILLER_NORM_RAND,
-    FILLER_EDGE_RAND,
-    FILLER_ACCESS_RAND,
+    FILLER_RAND,
   };
 
 private:
+
+  struct BurstQuality {
+    BurstQuality()
+      // 148 bits - burst length including guard bits
+      : phase_err(148), phase_err_deg(148)
+    {}
+
+    Vector<float> phase_err;
+    Vector<float> phase_err_deg;
+    int phase_err_max_idx;
+    float phase_err_max;
+    float phase_err_rms;
+  };
+
   int mBasePort;
-  std::string mLocalAddr;
-  std::string mRemoteAddr;
+  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
@@ -172,7 +189,7 @@ private:
 
   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 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
@@ -194,7 +211,7 @@ private:
   /** 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);
+                              size_t chan = 0, BurstQuality *qual = NULL);
 
   /** Set modulus for specific timeslot */
   void setModulus(size_t timeslot, size_t chan);
@@ -205,21 +222,44 @@ private:
   /** send messages over the clock socket */
   void writeClockInterface(void);
 
+  /** Detect RACH bursts */
+  int detectRACH(TransceiverState *state,
+                 signalVector &burst,
+                 complex &amp, float &toa);
+
+  /** Detect normal bursts */
+  int 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,
+                         GSM::Time &wTime, size_t chan,
+                         BurstQuality *qual=NULL);
+
   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 mForceClockInterface;           ///< flag to indicate whether IND CLOCK shall be sent unconditionally after transceiver is started
   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 mMaxExpectedDelay;          ///< maximum expected time-of-arrival offset in GSM symbols
   unsigned mWriteBurstToDiskMask;      ///< debug: bitmask to indicate which timeslots to dump to disk
 
+
+  bool needWriteBurstToDisk(const GSM::Time &wTime, size_t chan)
+  {
+    /* Debug: dump bursts to disk */
+    /* bits 0-7  - chan 0 timeslots
+     * bits 8-15 - chan 1 timeslots */
+    return mWriteBurstToDiskMask & ((1<<wTime.TN()) << (8*chan));
+  }
+
   std::vector<TransceiverState> mStates;
 
   /** Start and stop I/O threads through the control socket API */
@@ -230,6 +270,10 @@ private:
   Mutex mLock;
 
 protected:
+
+  /** Estimate received burst quality and print it to debug output */
+  void estimateBurstQuality(const BitVector &wBits, signalVector *received, const GSM::Time &wTime, size_t chan, BurstQuality &qual);
+
   /** drive lower receive I/O and burst generation */
   void driveReceiveRadio();
 
@@ -264,8 +308,6 @@ 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 *);
@@ -279,3 +321,4 @@ void *ControlServiceLoopAdapter(TransceiverChannel *);
 
 /** transmit queueing thread loop */
 void *TxUpperLoopAdapter(TransceiverChannel *);
+

Transceiver52M/UHDDevice.cpp

@@ -1,10 +1,8 @@
 /*
  * Device support for Ettus Research UHD driver 
+ * Written by Thomas Tsou <ttsou@vt.edu>
  *
  * Copyright 2010,2011 Free Software Foundation, Inc.
- * Copyright (C) 2015 Ettus Research LLC
- *
- * Author: Tom Tsou <tom.tsou@ettus.com>
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU Affero General Public License as published by
@@ -21,7 +19,6 @@
  * See the COPYING file in the main directory for details.
  */
 
-#include <map>
 #include "radioDevice.h"
 #include "Threads.h"
 #include "Logger.h"
@@ -29,18 +26,18 @@
 #include <uhd/property_tree.hpp>
 #include <uhd/usrp/multi_usrp.hpp>
 #include <uhd/utils/thread_priority.hpp>
+#include <uhd/utils/msg.hpp>
 
 #ifdef HAVE_CONFIG_H
 #include "config.h"
 #endif
 
-#ifndef USE_UHD_3_11
-#include <uhd/utils/msg.hpp>
-#endif
-
+#define B2XX_CLK_RT      26e6
+#define E1XX_CLK_RT      52e6
+#define B100_BASE_RT     400000
+#define USRP2_BASE_RT    390625
 #define USRP_TX_AMPL     0.3
 #define UMTRX_TX_AMPL    0.7
-#define LIMESDR_TX_AMPL  0.3
 #define SAMPLE_BUF_SZ    (1 << 20)
 
 /*
@@ -62,28 +59,19 @@ enum uhd_dev_type {
 	B100,
 	B200,
 	B210,
-	B2XX_MCBTS,
 	E1XX,
 	E3XX,
 	X3XX,
 	UMTRX,
-	LIMESDR,
+	NUM_USRP_TYPES,
 };
 
-/*
- * USRP version dependent device timings
- */
-#if defined(USE_UHD_3_9) || defined(USE_UHD_3_11)
-#define B2XX_TIMING_1SPS	1.7153e-4
-#define B2XX_TIMING_4SPS	1.1696e-4
-#define B2XX_TIMING_4_4SPS	6.18462e-5
-#define B2XX_TIMING_MCBTS	7e-5
-#else
-#define B2XX_TIMING_1SPS	9.9692e-5
-#define B2XX_TIMING_4SPS	6.9248e-5
-#define B2XX_TIMING_4_4SPS	4.52308e-5
-#define B2XX_TIMING_MCBTS	6.42452e-5
-#endif
+struct uhd_dev_offset {
+	enum uhd_dev_type type;
+	int sps;
+	double offset;
+	const std::string desc;
+};
 
 /*
  * Tx / Rx sample offset values. In a perfect world, there is no group delay
@@ -95,47 +83,138 @@ enum uhd_dev_type {
  * Notes:
  *   USRP1 with timestamps is not supported by UHD.
  */
-
-/* Device Type, Tx-SPS, Rx-SPS */
-typedef std::tuple<uhd_dev_type, int, int> dev_key;
-
-/* Device parameter descriptor */
-struct dev_desc {
-	unsigned channels;
-	double mcr;
-	double rate;
-	double offset;
-	std::string str;
-};
-
-static const std::map<dev_key, dev_desc> dev_param_map {
-	{ std::make_tuple(USRP2, 1, 1), { 1, 0.0,  390625,  1.2184e-4,  "N2XX 1 SPS"         } },
-	{ std::make_tuple(USRP2, 4, 1), { 1, 0.0,  390625,  7.6547e-5,  "N2XX 4/1 Tx/Rx SPS" } },
-	{ std::make_tuple(USRP2, 4, 4), { 1, 0.0,  390625,  4.6080e-5,  "N2XX 4 SPS"         } },
-	{ std::make_tuple(B100,  1, 1), { 1, 0.0,  400000,  1.2104e-4,  "B100 1 SPS"         } },
-	{ std::make_tuple(B100,  4, 1), { 1, 0.0,  400000,  7.9307e-5,  "B100 4/1 Tx/Rx SPS" } },
-	{ std::make_tuple(B200,  1, 1), { 1, 26e6, GSMRATE, B2XX_TIMING_1SPS, "B200 1 SPS"   } },
-	{ std::make_tuple(B200,  4, 1), { 1, 26e6, GSMRATE, B2XX_TIMING_4SPS, "B200 4/1 Tx/Rx SPS" } },
-	{ std::make_tuple(B200,  4, 4), { 1, 26e6, GSMRATE, B2XX_TIMING_4_4SPS, "B200 4 SPS" } },
-	{ std::make_tuple(B210,  1, 1), { 2, 26e6, GSMRATE, B2XX_TIMING_1SPS, "B210 1 SPS"    } },
-	{ std::make_tuple(B210,  4, 1), { 2, 26e6, GSMRATE, B2XX_TIMING_4SPS, "B210 4/1 Tx/Rx SPS" } },
-	{ std::make_tuple(B210,  4, 4), { 2, 26e6, GSMRATE, B2XX_TIMING_4_4SPS, "B210 4 SPS" } },
-	{ std::make_tuple(E1XX,  1, 1), { 1, 52e6, GSMRATE, 9.5192e-5,  "E1XX 1 SPS"         } },
-	{ std::make_tuple(E1XX,  4, 1), { 1, 52e6, GSMRATE, 6.5571e-5,  "E1XX 4/1 Tx/Rx SPS" } },
-	{ std::make_tuple(E3XX,  1, 1), { 2, 26e6, GSMRATE, 1.8462e-4,  "E3XX 1 SPS"         } },
-	{ std::make_tuple(E3XX,  4, 1), { 2, 26e6, GSMRATE, 1.2923e-4,  "E3XX 4/1 Tx/Rx SPS" } },
-	{ std::make_tuple(X3XX,  1, 1), { 2, 0.0,  390625,  1.5360e-4,  "X3XX 1 SPS"         } },
-	{ std::make_tuple(X3XX,  4, 1), { 2, 0.0,  390625,  1.1264e-4,  "X3XX 4/1 Tx/Rx SPS" } },
-	{ std::make_tuple(X3XX,  4, 4), { 2, 0.0,  390625,  5.6567e-5,  "X3XX 4 SPS"         } },
-	{ std::make_tuple(UMTRX, 1, 1), { 2, 0.0,  GSMRATE, 9.9692e-5,  "UmTRX 1 SPS"        } },
-	{ std::make_tuple(UMTRX, 4, 1), { 2, 0.0,  GSMRATE, 7.3846e-5,  "UmTRX 4/1 Tx/Rx SPS"} },
-	{ std::make_tuple(UMTRX, 4, 4), { 2, 0.0,  GSMRATE, 5.1503e-5,  "UmTRX 4 SPS"        } },
-	{ std::make_tuple(LIMESDR, 4, 4), { 1, GSMRATE*32, GSMRATE, 8.9e-5, "LimeSDR 4 SPS"  } },
-	{ std::make_tuple(B2XX_MCBTS, 4, 4), { 1, 51.2e6, MCBTS_SPACING*4, B2XX_TIMING_MCBTS, "B200/B210 4 SPS Multi-ARFCN" } },
+static struct uhd_dev_offset uhd_offsets[NUM_USRP_TYPES * 2] = {
+	{ USRP1, 1,       0.0, "USRP1 not supported" },
+	{ USRP1, 4,       0.0, "USRP1 not supported"},
+	{ USRP2, 1, 1.2184e-4, "N2XX 1 SPS" },
+	{ USRP2, 4, 8.0230e-5, "N2XX 4 SPS" },
+	{ B100,  1, 1.2104e-4, "B100 1 SPS" },
+	{ B100,  4, 7.9307e-5, "B100 4 SPS" },
+	{ B200,  1, 9.9692e-5, "B200 1 SPS" },
+	{ B200,  4, 6.9248e-5, "B200 4 SPS" },
+	{ B210,  1, 9.9692e-5, "B210 1 SPS" },
+	{ B210,  4, 6.9248e-5, "B210 4 SPS" },
+	{ E1XX,  1, 9.5192e-5, "E1XX 1 SPS" },
+	{ E1XX,  4, 6.5571e-5, "E1XX 4 SPS" },
+	{ E3XX,  1, 1.5000e-4, "E3XX 1 SPS" },
+	{ E3XX,  4, 1.2740e-4, "E3XX 4 SPS" },
+	{ X3XX,  1, 1.5360e-4, "X3XX 1 SPS"},
+	{ X3XX,  4, 1.1264e-4, "X3XX 4 SPS"},
+	{ UMTRX, 1, 9.9692e-5, "UmTRX 1 SPS" },
+	{ UMTRX, 4, 7.3846e-5, "UmTRX 4 SPS" },
 };
 
 /*
-    Sample Buffer - Allows reading and writing of timed samples using osmo-trx
+ * Offset handling for special cases. Currently used for UmTRX dual channel
+ * diversity receiver only.
+ */
+static struct uhd_dev_offset special_offsets[] = {
+	{ UMTRX, 1, 8.0875e-5, "UmTRX diversity, 1 SPS" },
+	{ UMTRX, 4, 5.2103e-5, "UmTRX diversity, 4 SPS" },
+};
+
+static double get_dev_offset(enum uhd_dev_type type,
+			     int sps, bool diversity = false)
+{
+	struct uhd_dev_offset *offset = NULL;
+
+	/* Reject USRP1 */
+	if (type == USRP1) {
+		LOG(ERR) << "Invalid device type";
+		return 0.0;
+	}
+
+	/* Special cases (e.g. diversity receiver) */
+	if (diversity) {
+		if (type != UMTRX) {
+			LOG(ALERT) << "Diversity on UmTRX only";
+			return 0.0;
+		}
+
+		switch (sps) {
+		case 1:
+			offset = &special_offsets[0];
+			break;
+		case 4:
+		default:
+			offset = &special_offsets[1];
+		}
+	} else {
+		/* Search for matching offset value */
+		for (int i = 0; i < NUM_USRP_TYPES * 2; i++) {
+			if ((type == uhd_offsets[i].type) &&
+                            (sps == uhd_offsets[i].sps)) {
+				offset = &uhd_offsets[i];
+				break;
+			}
+		}
+	}
+
+	if (!offset) {
+		LOG(ERR) << "Invalid device configuration";
+		return 0.0;
+	}
+
+	std::cout << "-- Setting " << offset->desc << std::endl;
+
+	return offset->offset;
+}
+
+/*
+ * Select sample rate based on device type and requested samples-per-symbol.
+ * The base rate is either GSM symbol rate, 270.833 kHz, or the minimum
+ * usable channel spacing of 400 kHz.
+ */
+static double select_rate(uhd_dev_type type, int sps, bool diversity = false)
+{
+	if (diversity && (type == UMTRX)) {
+		return GSMRATE * 4;
+	} else if (diversity) {
+		LOG(ALERT) << "Diversity supported on UmTRX only";
+		return -9999.99;
+	}
+
+	if ((sps != 4) && (sps != 1))
+		return -9999.99;
+
+	switch (type) {
+	case USRP2:
+	case X3XX:
+		return USRP2_BASE_RT * sps;
+	case B100:
+		return B100_BASE_RT * sps;
+	case B200:
+	case B210:
+	case E1XX:
+	case E3XX:
+	case UMTRX:
+		return GSMRATE * sps;
+	default:
+		break;
+	}
+
+	LOG(ALERT) << "Unknown device type " << type;
+	return -9999.99;
+}
+
+/** Timestamp conversion
+    @param timestamp a UHD or OpenBTS timestamp
+    @param rate sample rate
+    @return the converted timestamp
+*/
+uhd::time_spec_t convert_time(TIMESTAMP ticks, double rate)
+{
+	double secs = (double) ticks / rate;
+	return uhd::time_spec_t(secs);
+}
+
+TIMESTAMP convert_time(uhd::time_spec_t ts, double rate)
+{
+	return (TIMESTAMP)(ts.get_real_secs() * rate + 0.5);
+}
+
+/*
+    Sample Buffer - Allows reading and writing of timed samples using OpenBTS
                     or UHD style timestamps. Time conversions are handled
                     internally or accessable through the static convert calls.
 */
@@ -207,11 +286,10 @@ private:
 */
 class uhd_device : public RadioDevice {
 public:
-	uhd_device(size_t tx_sps, size_t rx_sps, InterfaceType type,
-		   size_t chans, double offset);
+	uhd_device(size_t sps, size_t chans, bool diversity, double offset);
 	~uhd_device();
 
-	int open(const std::string &args, int ref, bool swap_channels);
+	int open(const std::string &args, bool extref, bool swap_channels);
 	bool start();
 	bool stop();
 	bool restart();
@@ -229,8 +307,8 @@ public:
 	bool setTxFreq(double wFreq, size_t chan);
 	bool setRxFreq(double wFreq, size_t chan);
 
-	TIMESTAMP initialWriteTimestamp();
-	TIMESTAMP initialReadTimestamp();
+	inline TIMESTAMP initialWriteTimestamp() { return ts_initial * sps; }
+	inline TIMESTAMP initialReadTimestamp() { return ts_initial; }
 
 	double fullScaleInputValue();
 	double fullScaleOutputValue();
@@ -271,7 +349,7 @@ private:
 	enum TxWindowType tx_window;
 	enum uhd_dev_type dev_type;
 
-	size_t tx_sps, rx_sps, chans;
+	size_t sps, chans;
 	double tx_rate, rx_rate;
 
 	double tx_gain_min, tx_gain_max;
@@ -293,8 +371,8 @@ private:
 	std::vector<smpl_buf *> rx_buffers;
 
 	void init_gains();
-	void set_channels(bool swap);
-	void set_rates();
+	int set_master_clk(double rate);
+	int set_rates(double tx_rate, double rx_rate);
 	bool parse_dev_type();
 	bool flush_recv(size_t num_pkts);
 	int check_rx_md_err(uhd::rx_metadata_t &md, ssize_t num_smpls);
@@ -306,7 +384,7 @@ private:
 	bool set_freq(double freq, size_t chan, bool tx);
 
 	Thread *async_event_thrd;
-	InterfaceType iface;
+	bool diversity;
 	Mutex tune_lock;
 };
 
@@ -322,8 +400,7 @@ void *async_event_loop(uhd_device *dev)
 	return NULL;
 }
 
-#ifndef USE_UHD_3_11
-/*
+/* 
     Catch and drop underrun 'U' and overrun 'O' messages from stdout
     since we already report using the logging facility. Direct
     everything else appropriately.
@@ -344,7 +421,6 @@ void uhd_msg_handler(uhd::msg::type_t type, const std::string &msg)
 		break;
 	}
 }
-#endif
 
 static void thread_enable_cancel(bool cancel)
 {
@@ -352,19 +428,17 @@ static void thread_enable_cancel(bool cancel)
 		 pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, NULL);
 }
 
-uhd_device::uhd_device(size_t tx_sps, size_t rx_sps,
-		       InterfaceType iface, size_t chans, double offset)
+uhd_device::uhd_device(size_t sps, size_t chans, bool diversity, double offset)
 	: tx_gain_min(0.0), tx_gain_max(0.0),
 	  rx_gain_min(0.0), rx_gain_max(0.0),
 	  tx_spp(0), rx_spp(0),
 	  started(false), aligned(false), rx_pkt_cnt(0), drop_cnt(0),
 	  prev_ts(0,0), ts_initial(0), ts_offset(0)
 {
-	this->tx_sps = tx_sps;
-	this->rx_sps = rx_sps;
+	this->sps = sps;
 	this->chans = chans;
 	this->offset = offset;
-	this->iface = iface;
+	this->diversity = diversity;
 }
 
 uhd_device::~uhd_device()
@@ -423,29 +497,72 @@ void uhd_device::init_gains()
 
 }
 
-void uhd_device::set_rates()
+int uhd_device::set_master_clk(double clk_rate)
 {
-	dev_desc desc = dev_param_map.at(dev_key(dev_type, tx_sps, rx_sps));
-	if (desc.mcr != 0.0)
-		usrp_dev->set_master_clock_rate(desc.mcr);
+	double actual, offset, limit = 1.0;
 
-	tx_rate = (dev_type != B2XX_MCBTS) ? desc.rate * tx_sps : desc.rate;
-	rx_rate = (dev_type != B2XX_MCBTS) ? desc.rate * rx_sps : desc.rate;
+	try {
+		usrp_dev->set_master_clock_rate(clk_rate);
+	} catch (const std::exception &ex) {
+		LOG(ALERT) << "UHD clock rate setting failed: " << clk_rate;
+		LOG(ALERT) << ex.what();
+		return -1;
+	}
 
-	usrp_dev->set_tx_rate(tx_rate);
-	usrp_dev->set_rx_rate(rx_rate);
-	tx_rate = usrp_dev->get_tx_rate();
-	rx_rate = usrp_dev->get_rx_rate();
+	actual = usrp_dev->get_master_clock_rate();
+	offset = fabs(clk_rate - actual);
 
-	ts_offset = static_cast<TIMESTAMP>(desc.offset * rx_rate);
-	LOG(INFO) << "Rates configured for " << desc.str;
+	if (offset > limit) {
+		LOG(ALERT) << "Failed to set master clock rate";
+		LOG(ALERT) << "Requested clock rate " << clk_rate;
+		LOG(ALERT) << "Actual clock rate " << actual;
+		return -1;
+	}
+
+	return 0;
+}
+
+int uhd_device::set_rates(double tx_rate, double rx_rate)
+{
+	double offset_limit = 1.0;
+	double tx_offset, rx_offset;
+
+	/* B2XX and E1xx are the only device where we set FPGA clocking */
+	if ((dev_type == B200) || (dev_type == B210) || (dev_type == E3XX)) {
+		if (set_master_clk(B2XX_CLK_RT) < 0)
+			return -1;
+	}
+	else if (dev_type == E1XX) {
+		if (set_master_clk(E1XX_CLK_RT) < 0)
+			return -1;
+	}
+
+	// Set sample rates
+	try {
+		usrp_dev->set_tx_rate(tx_rate);
+		usrp_dev->set_rx_rate(rx_rate);
+	} catch (const std::exception &ex) {
+		LOG(ALERT) << "UHD rate setting failed";
+		LOG(ALERT) << ex.what();
+		return -1;
+	}
+	this->tx_rate = usrp_dev->get_tx_rate();
+	this->rx_rate = usrp_dev->get_rx_rate();
+
+	tx_offset = fabs(this->tx_rate - tx_rate);
+	rx_offset = fabs(this->rx_rate - rx_rate);
+	if ((tx_offset > offset_limit) || (rx_offset > offset_limit)) {
+		LOG(ALERT) << "Actual sample rate differs from desired rate";
+		LOG(ALERT) << "Tx/Rx (" << this->tx_rate << "/"
+			   << this->rx_rate << ")";
+		return -1;
+	}
+
+	return 0;
 }
 
 double uhd_device::setTxGain(double db, size_t chan)
 {
-	if (iface == MULTI_ARFCN)
-		chan = 0;
-
 	if (chan >= tx_gains.size()) {
 		LOG(ALERT) << "Requested non-existent channel" << chan;
 		return 0.0f;
@@ -492,9 +609,6 @@ double uhd_device::setRxGain(double db, size_t chan)
 
 double uhd_device::getRxGain(size_t chan)
 {
-	if (iface == MULTI_ARFCN)
-		chan = 0;
-
 	if (chan >= rx_gains.size()) {
 		LOG(ALERT) << "Requested non-existent channel " << chan;
 		return 0.0f;
@@ -511,106 +625,82 @@ double uhd_device::getRxGain(size_t chan)
  */
 bool uhd_device::parse_dev_type()
 {
-	uhd::property_tree::sptr prop_tree = usrp_dev->get_device()->get_tree();
-	std::string devString = prop_tree->access<std::string>("/name").get();
-	std::string mboardString = usrp_dev->get_mboard_name();
+	std::string mboard_str, dev_str;
+	uhd::property_tree::sptr prop_tree;
+	size_t usrp1_str, usrp2_str, e100_str, e110_str, e310_str,
+	       b100_str, b200_str, b210_str, x300_str, x310_str, umtrx_str;
 
-	const std::map<std::string, std::pair<uhd_dev_type, TxWindowType>> devStringMap {
-		{ "B100",     { B100,    TX_WINDOW_USRP1 } },
-		{ "B200",     { B200,    TX_WINDOW_USRP1 } },
-		{ "B200mini", { B200,    TX_WINDOW_USRP1 } },
-		{ "B205mini", { B200,    TX_WINDOW_USRP1 } },
-		{ "B210",     { B210,    TX_WINDOW_USRP1 } },
-		{ "E100",     { E1XX,    TX_WINDOW_FIXED } },
-		{ "E110",     { E1XX,    TX_WINDOW_FIXED } },
-		{ "E310",     { E3XX,    TX_WINDOW_FIXED } },
-		{ "E3XX",     { E3XX,    TX_WINDOW_FIXED } },
-		{ "X300",     { X3XX,    TX_WINDOW_FIXED } },
-		{ "X310",     { X3XX,    TX_WINDOW_FIXED } },
-		{ "USRP2",    { USRP2,   TX_WINDOW_FIXED } },
-		{ "UmTRX",    { UMTRX,   TX_WINDOW_FIXED } },
-		{ "LimeSDR",  { LIMESDR, TX_WINDOW_FIXED } },
-	};
+	prop_tree = usrp_dev->get_device()->get_tree();
+	dev_str = prop_tree->access<std::string>("/name").get();
+	mboard_str = usrp_dev->get_mboard_name();
 
-	// Compare UHD motherboard and device strings */
-	auto mapIter = devStringMap.begin();
-	while (mapIter != devStringMap.end()) {
-		if (devString.find(mapIter->first) != std::string::npos ||
-		    mboardString.find(mapIter->first) != std::string::npos) {
-			dev_type = std::get<0>(mapIter->second);
-			tx_window = std::get<1>(mapIter->second);
-			return true;
-		}
-		mapIter++;
+	usrp1_str = dev_str.find("USRP1");
+	usrp2_str = dev_str.find("USRP2");
+	b100_str = mboard_str.find("B100");
+	b200_str = mboard_str.find("B200");
+	b210_str = mboard_str.find("B210");
+	e100_str = mboard_str.find("E100");
+	e110_str = mboard_str.find("E110");
+	e310_str = mboard_str.find("E310");
+	x300_str = mboard_str.find("X300");
+	x310_str = mboard_str.find("X310");
+	umtrx_str = dev_str.find("UmTRX");
+
+	if (usrp1_str != std::string::npos) {
+		LOG(ALERT) << "USRP1 is not supported using the UHD driver";
+		LOG(ALERT) << "Please compile with GNU Radio libusrp support";
+		dev_type = USRP1;
+		return false;
 	}
 
-	LOG(ALERT) << "Unsupported device " << devString;
-	return false;
-}
-
-/*
- * Check for UHD version > 3.9.0 for E3XX support
- */
-static bool uhd_e3xx_version_chk()
-{
-	std::string ver = uhd::get_version_string();
-	std::string major_str(ver.begin(), ver.begin() + 3);
-	std::string minor_str(ver.begin() + 4, ver.begin() + 7);
-
-	int major_val = atoi(major_str.c_str());
-	int minor_val = atoi(minor_str.c_str());
-
-	if (major_val < 3)
-		return false;
-	if (minor_val < 9)
+	if (b100_str != std::string::npos) {
+		tx_window = TX_WINDOW_USRP1;
+		dev_type = B100;
+	} else if (b200_str != std::string::npos) {
+		tx_window = TX_WINDOW_USRP1;
+		dev_type = B200;
+	} else if (b210_str != std::string::npos) {
+		tx_window = TX_WINDOW_USRP1;
+		dev_type = B210;
+	} else if (e100_str != std::string::npos) {
+		tx_window = TX_WINDOW_FIXED;
+		dev_type = E1XX;
+	} else if (e110_str != std::string::npos) {
+		tx_window = TX_WINDOW_FIXED;
+		dev_type = E1XX;
+	} else if (usrp2_str != std::string::npos) {
+		tx_window = TX_WINDOW_FIXED;
+		dev_type = USRP2;
+	} else if (e310_str != std::string::npos) {
+		tx_window = TX_WINDOW_FIXED;
+		dev_type = E3XX;
+	} else if (x300_str != std::string::npos) {
+		tx_window = TX_WINDOW_FIXED;
+		dev_type = X3XX;
+	} else if (x310_str != std::string::npos) {
+		tx_window = TX_WINDOW_FIXED;
+		dev_type = X3XX;
+	} else if (umtrx_str != std::string::npos) {
+		tx_window = TX_WINDOW_FIXED;
+		dev_type = UMTRX;
+	} else {
+		LOG(ALERT) << "Unknown UHD device type " << dev_str;
 		return false;
+	}
+
+	if (tx_window == TX_WINDOW_USRP1) {
+		LOG(INFO) << "Using USRP1 type transmit window for "
+			  << dev_str << " " << mboard_str;
+	} else {
+		LOG(INFO) << "Using fixed transmit window for "
+			  << dev_str << " " << mboard_str;
+	}
 
 	return true;
 }
 
-void uhd_device::set_channels(bool swap)
+int uhd_device::open(const std::string &args, bool extref, bool swap_channels)
 {
-	if (iface == MULTI_ARFCN) {
-		if (dev_type != B200 && dev_type != B210)
-			throw std::invalid_argument("Device does not support MCBTS");
-		dev_type = B2XX_MCBTS;
-		chans = 1;
-	}
-
-	if (chans > dev_param_map.at(dev_key(dev_type, tx_sps, rx_sps)).channels)
-		throw std::invalid_argument("Device does not support number of requested channels");
-
-	std::string subdev_string;
-	switch (dev_type) {
-	case B210:
-	case E3XX:
-		if (chans == 1)
-			subdev_string = swap ? "A:B" : "A:A";
-		else if (chans == 2)
-			subdev_string = swap ? "A:B A:A" : "A:A A:B";
-		break;
-	case X3XX:
-	case UMTRX:
-		if (chans == 1)
-			subdev_string = swap ? "B:0" : "A:0";
-		else if (chans == 2)
-			subdev_string = swap ? "B:0 A:0" : "A:0 B:0";
-		break;
-	default:
-		break;
-	}
-
-	if (!subdev_string.empty()) {
-		uhd::usrp::subdev_spec_t spec(subdev_string);
-		usrp_dev->set_tx_subdev_spec(spec);
-		usrp_dev->set_rx_subdev_spec(spec);
-	}
-}
-
-int uhd_device::open(const std::string &args, int ref, bool swap_channels)
-{
-	const char *refstr;
-
 	// Find UHD devices
 	uhd::device_addr_t addr(args);
 	uhd::device_addrs_t dev_addrs = uhd::device::find(addr);
@@ -632,15 +722,14 @@ int uhd_device::open(const std::string &args, int ref, bool swap_channels)
 	if (!parse_dev_type())
 		return -1;
 
-	if ((dev_type == E3XX) && !uhd_e3xx_version_chk()) {
-		LOG(ALERT) << "E3XX requires UHD 003.009.000 or greater";
-		return -1;
-	}
-
-	try {
-		set_channels(swap_channels);
-        } catch (const std::exception &e) {
-		LOG(ALERT) << "Channel setting failed - " << e.what();
+	// Verify and set channels
+	if ((dev_type == B210) && (chans == 2)) {
+	} else if ((dev_type == UMTRX) && (chans == 2)) {
+		uhd::usrp::subdev_spec_t subdev_spec(swap_channels?"B:0 A:0":"A:0 B:0");
+		usrp_dev->set_tx_subdev_spec(subdev_spec);
+		usrp_dev->set_rx_subdev_spec(subdev_spec);
+	} else if (chans != 1) {
+		LOG(ALERT) << "Invalid channel combination for device";
 		return -1;
 	}
 
@@ -650,41 +739,29 @@ int uhd_device::open(const std::string &args, int ref, bool swap_channels)
 	rx_gains.resize(chans);
 	rx_buffers.resize(chans);
 
-	switch (ref) {
-	case REF_INTERNAL:
-		refstr = "internal";
-		break;
-	case REF_EXTERNAL:
-		refstr = "external";
-		break;
-	case REF_GPS:
-		refstr = "gpsdo";
-		break;
-	default:
-		LOG(ALERT) << "Invalid reference type";
-		return -1;
-	}
+	if (extref)
+		usrp_dev->set_clock_source("external");
 
-	usrp_dev->set_clock_source(refstr);
+	// Set rates
+	double _rx_rate;
+	double _tx_rate = select_rate(dev_type, sps);
+	if (diversity)
+		_rx_rate = select_rate(dev_type, 1, true);
+	else
+		_rx_rate = _tx_rate / sps;
 
-	try {
-		set_rates();
-        } catch (const std::exception &e) {
-		LOG(ALERT) << "UHD rate setting failed - " << e.what();
+	if ((_tx_rate < 0.0) || (_rx_rate < 0.0))
+		return -1;
+	if (set_rates(_tx_rate, _rx_rate) < 0)
 		return -1;
-	}
 
 	// Set RF frontend bandwidth
 	if (dev_type == UMTRX) {
 		// Setting LMS6002D LPF to 500kHz gives us the best signal quality
 		for (size_t i = 0; i < chans; i++) {
 			usrp_dev->set_tx_bandwidth(500*1000*2, i);
-			usrp_dev->set_rx_bandwidth(500*1000*2, i);
-		}
-	} else if (dev_type == LIMESDR) {
-		for (size_t i = 0; i < chans; i++) {
-			usrp_dev->set_tx_bandwidth(5e6, i);
-			usrp_dev->set_rx_bandwidth(5e6, i);
+			if (!diversity)
+				usrp_dev->set_rx_bandwidth(500*1000*2, i);
 		}
 	}
 
@@ -705,14 +782,23 @@ int uhd_device::open(const std::string &args, int ref, bool swap_channels)
 	for (size_t i = 0; i < rx_buffers.size(); i++)
 		rx_buffers[i] = new smpl_buf(buf_len, rx_rate);
 
+	// Set receive chain sample offset 
+	double offset = get_dev_offset(dev_type, sps, diversity);
+	if (offset == 0.0) {
+		LOG(ERR) << "Unsupported configuration, no correction applied";
+		ts_offset = 0;
+	} else  {
+		ts_offset = (TIMESTAMP) (offset * rx_rate);
+	}
+
 	// Initialize and shadow gain values 
 	init_gains();
 
 	// Print configuration
 	LOG(INFO) << "\n" << usrp_dev->get_pp_string();
 
-	if (iface == MULTI_ARFCN)
-		return MULTI_ARFCN;
+	if (diversity)
+		return DIVERSITY;
 
 	switch (dev_type) {
 	case B100:
@@ -724,7 +810,6 @@ int uhd_device::open(const std::string &args, int ref, bool swap_channels)
 	case B210:
 	case E1XX:
 	case E3XX:
-	case LIMESDR:
 	default:
 		break;
 	}
@@ -759,7 +844,7 @@ bool uhd_device::flush_recv(size_t num_pkts)
 			}
 		}
 
-		ts_initial = md.time_spec.to_ticks(rx_rate);
+		ts_initial = convert_time(md.time_spec, rx_rate);
 	}
 
 	LOG(INFO) << "Initial timestamp " << ts_initial << std::endl;
@@ -794,10 +879,9 @@ bool uhd_device::start()
 		return false;
 	}
 
-#ifndef USE_UHD_3_11
 	// Register msg handler
 	uhd::msg::register_handler(&uhd_msg_handler);
-#endif
+
 	// Start asynchronous event (underrun check) loop
 	async_event_thrd = new Thread();
 	async_event_thrd->start((void * (*)(void*))async_event_loop, (void*)this);
@@ -840,6 +924,8 @@ void uhd_device::setPriority(float prio)
 
 int uhd_device::check_rx_md_err(uhd::rx_metadata_t &md, ssize_t num_smpls)
 {
+	uhd::time_spec_t ts;
+
 	if (!num_smpls) {
 		LOG(ERR) << str_code(md);
 
@@ -862,21 +948,18 @@ int uhd_device::check_rx_md_err(uhd::rx_metadata_t &md, ssize_t num_smpls)
 		return ERROR_UNRECOVERABLE;
 	}
 
+	ts = md.time_spec;
+
 	// Monotonicity check
-	if (md.time_spec < prev_ts) {
+	if (ts < prev_ts) {
 		LOG(ALERT) << "UHD: Loss of monotonic time";
-		LOG(ALERT) << "Current time: " << md.time_spec.get_real_secs() << ", "
+		LOG(ALERT) << "Current time: " << ts.get_real_secs() << ", " 
 			   << "Previous time: " << prev_ts.get_real_secs();
 		return ERROR_TIMING;
+	} else {
+		prev_ts = ts;
 	}
 
-	// Workaround for UHD tick rounding bug
-	TIMESTAMP ticks = md.time_spec.to_ticks(rx_rate);
-	if (ticks - prev_ts.to_ticks(rx_rate) == rx_spp - 1)
-		md.time_spec = uhd::time_spec_t::from_ticks(++ticks, rx_rate);
-
-	prev_ts = md.time_spec;
-
 	return 0;
 }
 
@@ -898,7 +981,7 @@ int uhd_device::readSamples(std::vector<short *> &bufs, int len, bool *overrun,
 	// Shift read time with respect to transmit clock
 	timestamp += ts_offset;
 
-	ts = uhd::time_spec_t::from_ticks(timestamp, rx_rate);
+	ts = convert_time(timestamp, rx_rate);
 	LOG(DEBUG) << "Requested timestamp = " << ts.get_real_secs();
 
 	// Check that timestamp is valid
@@ -980,7 +1063,7 @@ int uhd_device::writeSamples(std::vector<short *> &bufs, int len, bool *underrun
 	metadata.has_time_spec = true;
 	metadata.start_of_burst = false;
 	metadata.end_of_burst = false;
-	metadata.time_spec = uhd::time_spec_t::from_ticks(timestamp, tx_rate);
+	metadata.time_spec = convert_time(timestamp, tx_rate);
 
 	*underrun = false;
 
@@ -1070,7 +1153,7 @@ uhd::tune_request_t uhd_device::select_freq(double freq, size_t chan, bool tx)
 
 	/* Find center frequency between channels */
 	rf_spread = fabs(freqs[!chan] - freq);
-	if (rf_spread > dev_param_map.at(dev_key(B210, tx_sps, rx_sps)).mcr) {
+	if (rf_spread > B2XX_CLK_RT) {
 		LOG(ALERT) << rf_spread << "Hz tuning spread not supported\n";
 		return treq;
 	}
@@ -1165,28 +1248,8 @@ double uhd_device::getRxFreq(size_t chan)
 	return rx_freqs[chan];
 }
 
-/*
- * Only allow sampling the Rx path lower than Tx and not vice-versa.
- * Using Tx with 4 SPS and Rx at 1 SPS is the only allowed mixed
- * combination.
- */
-TIMESTAMP uhd_device::initialWriteTimestamp()
-{
-	if ((iface == MULTI_ARFCN) || (rx_sps == tx_sps))
-		return ts_initial;
-	else
-		return ts_initial * tx_sps;
-}
-
-TIMESTAMP uhd_device::initialReadTimestamp()
-{
-	return ts_initial;
-}
-
 double uhd_device::fullScaleInputValue()
 {
-	if (dev_type == LIMESDR)
-		return (double) SHRT_MAX * LIMESDR_TX_AMPL;
 	if (dev_type == UMTRX)
 		return (double) SHRT_MAX * UMTRX_TX_AMPL;
 	else
@@ -1314,7 +1377,7 @@ ssize_t smpl_buf::avail_smpls(TIMESTAMP timestamp) const
 
 ssize_t smpl_buf::avail_smpls(uhd::time_spec_t timespec) const
 {
-	return avail_smpls(timespec.to_ticks(clk_rt));
+	return avail_smpls(convert_time(timespec, clk_rt));
 }
 
 ssize_t smpl_buf::read(void *buf, size_t len, TIMESTAMP timestamp)
@@ -1360,7 +1423,7 @@ ssize_t smpl_buf::read(void *buf, size_t len, TIMESTAMP timestamp)
 
 ssize_t smpl_buf::read(void *buf, size_t len, uhd::time_spec_t ts)
 {
-	return read(buf, len, ts.to_ticks(clk_rt));
+	return read(buf, len, convert_time(ts, clk_rt));
 }
 
 ssize_t smpl_buf::write(void *buf, size_t len, TIMESTAMP timestamp)
@@ -1375,14 +1438,14 @@ ssize_t smpl_buf::write(void *buf, size_t len, TIMESTAMP timestamp)
 
 	if (timestamp < time_end) {
 		LOG(ERR) << "Overwriting old buffer data: timestamp="<<timestamp<<" time_end="<<time_end;
-		uhd::time_spec_t ts = uhd::time_spec_t::from_ticks(timestamp, clk_rt);
-		LOG(DEBUG) << "Requested timestamp = " << timestamp << " (real_sec=" << std::fixed << ts.get_real_secs() << " = " << ts.to_ticks(clk_rt) << ") rate=" << clk_rt;
+		uhd::time_spec_t ts = convert_time(timestamp, clk_rt);
+		LOG(DEBUG) << "Requested timestamp = " << timestamp << " (real_sec=" << std::fixed << ts.get_real_secs() << " = " << convert_time(ts, clk_rt) << ") rate=" << clk_rt;
 		// Do not return error here, because it's a rounding error and is not fatal
 	}
 	if (timestamp > time_end && time_end != 0) {
 		LOG(ERR) << "Skipping buffer data: timestamp="<<timestamp<<" time_end="<<time_end;
-		uhd::time_spec_t ts = uhd::time_spec_t::from_ticks(timestamp, clk_rt);
-		LOG(DEBUG) << "Requested timestamp = " << timestamp << " (real_sec=" << std::fixed << ts.get_real_secs() << " = " << ts.to_ticks(clk_rt) << ") rate=" << clk_rt;
+		uhd::time_spec_t ts = convert_time(timestamp, clk_rt);
+		LOG(DEBUG) << "Requested timestamp = " << timestamp << " (real_sec=" << std::fixed << ts.get_real_secs() << " = " << convert_time(ts, clk_rt) << ") rate=" << clk_rt;
 		// Do not return error here, because it's a rounding error and is not fatal
 	}
 
@@ -1417,7 +1480,7 @@ ssize_t smpl_buf::write(void *buf, size_t len, TIMESTAMP timestamp)
 
 ssize_t smpl_buf::write(void *buf, size_t len, uhd::time_spec_t ts)
 {
-	return write(buf, len, ts.to_ticks(clk_rt));
+	return write(buf, len, convert_time(ts, clk_rt));
 }
 
 std::string smpl_buf::str_status(size_t ts) const
@@ -1450,8 +1513,8 @@ std::string smpl_buf::str_code(ssize_t code)
 	}
 }
 
-RadioDevice *RadioDevice::make(size_t tx_sps, size_t rx_sps,
-			       InterfaceType iface, size_t chans, double offset)
+RadioDevice *RadioDevice::make(size_t sps, size_t chans,
+			       bool diversity, double offset)
 {
-	return new uhd_device(tx_sps, rx_sps, iface, chans, offset);
+	return new uhd_device(sps, chans, diversity, offset);
 }

Transceiver52M/USRPDevice.cpp

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

Transceiver52M/USRPDevice.h

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

Transceiver52M/XTRXDevice.cpp

@@ -1,397 +0,0 @@
-#include <stdint.h>
-#include <string.h>
-#include <stdlib.h>
-#include "Threads.h"
-#include "XTRXDevice.h"
-
-#include <Logger.h>
-#include <errno.h>
-
-#ifdef HAVE_CONFIG_H
-#include "config.h"
-#endif
-
-using namespace std;
-
-const double defaultRXBandwidth = 2e6;
-const double defaultTXBandwidth = 3e6;
-
-static int time_tx_corr = 60; //20+20+20+20+20;
-
-XTRXDevice::XTRXDevice(size_t txsps, size_t rxsps)
-{
-  LOG(INFO) << "creating XTRX device...";
-
-  this->txsps = txsps;
-  this->rxsps = rxsps;
-
-  rxGain = 0;
-
-  loopback = false;
-  device = NULL;
-}
-
-static int parse_config(const char* line, const char* argument, int default_value)
-{
-    const char* arg_found = strstr(line, argument);
-    if (!arg_found)
-        return default_value;
-
-    const char* qe_pos = strchr(arg_found, '=');
-    if (!qe_pos)
-        return default_value;
-
-    int res = strtol(qe_pos + 1, NULL, 10);
-    if (res == 0 && errno) {
-        return default_value;
-    }
-
-    return res;
-}
-
-int XTRXDevice::open(const std::string &args, int ref, bool swap_channels)
-{
-  LOG(INFO) << "opening XTRX device '"  << args << "'..";
-
-  int loglevel = parse_config(args.c_str(), "loglevel", 3);
-  int lb_param = parse_config(args.c_str(), "loopback", 0);
-  time_tx_corr = parse_config(args.c_str(), "tcorr", time_tx_corr);
-  int fref     = parse_config(args.c_str(), "refclk", 30720000);
-  int rxdec    = parse_config(args.c_str(), "rxdec", 0);
-
-  char xtrx_name[500];
-  const char* lend = strchr(args.c_str(), ',');
-  int len = (lend) ? (lend - args.c_str()) : sizeof(xtrx_name) - 1;
-  strncpy(xtrx_name, args.c_str(), len);
-  xtrx_name[len] = 0;
-
-  if (lb_param) {
-      LOG(ALERT) << "XTRX LOOPBACK mode is set!";
-      loopback = true;
-  }
-
-  int res = xtrx_open(xtrx_name, loglevel, &device);
-  if (res) {
-    LOG(ALERT) << "XTRX creating failed, device " << xtrx_name << " code " << res;
-    return -1;
-  }
-  double actualMasterClock = 0;
-
-  if (fref > 0) {
-	xtrx_set_ref_clk(device, fref, XTRX_CLKSRC_INT);
-  }
-
-  res = xtrx_set_samplerate(device,
-							GSMRATE * (double) std::min(txsps, rxsps)  * 32 * 4 * ((rxdec) ? 2 : 1),
-							GSMRATE * (double) rxsps,
-							GSMRATE * (double) txsps,
-							(rxdec) ? XTRX_SAMPLERATE_FORCE_RX_DECIM : 0,
-                            &actualMasterClock,
-                            &actualRXSampleRate,
-                            &actualTXSampleRate);
-  if (res) {
-	  LOG(ALERT) << "XTRX failed to set samplerate RX: " << GSMRATE * (double) rxsps
-				 << " TX: " << GSMRATE * (double) txsps
-                 << " res: " << res;
-      return -1;
-  } else {
-      LOG(INFO) << "XTRX set samplerate Master: " << actualMasterClock
-                << " RX: " << actualRXSampleRate
-                << " TX: " << actualTXSampleRate;
-  }
-
-
-  int i;
-  double bw;
-  double actualbw;
-
-  actualbw = 0;
-  bw = defaultRXBandwidth;
-  for (i = 0, res = -1; res && (i < 4); i++, bw *= 1.5) {
-      res = xtrx_tune_rx_bandwidth(device, XTRX_CH_AB, bw, &actualbw);
-  }
-  if (res) {
-      LOG(ALERT) << "XTRX failed to set RX bandwidth: " << bw
-                 << " res: " << res;
-      return -1;
-  } else {
-      LOG(INFO) << "XTRX set RX bandwidth: " << actualbw;
-  }
-
-  actualbw = 0;
-  bw = defaultTXBandwidth;
-  for (i = 0, res = -1; res && (i < 4); i++, bw *= 1.1) {
-      res = xtrx_tune_tx_bandwidth(device, XTRX_CH_AB, bw, &actualbw);
-  }
-  if (res) {
-      LOG(ALERT) << "XTRX failed to set TX bandwidth: " << bw
-                 << " res: " << res;
-      return -1;
-  } else {
-      LOG(INFO) << "XTRX set TX bandwidth: " << actualbw;
-  }
-
-  samplesRead = 0;
-  samplesWritten = 0;
-  started = false;
-
-  return NORMAL;
-}
-
-XTRXDevice::~XTRXDevice()
-{
-    if (device) {
-        xtrx_close(device);
-    }
-}
-
-bool XTRXDevice::start() 
-{
-  LOG(INFO) << "starting XTRX...";
-  if (started) {
-      return false;
-  }
-
-  dataStart = 0;
-  dataEnd = 0;
-  timeStart = 0;
-  timeEnd = 0;
-  timeRx = initialReadTimestamp();
-  timestampOffset = 0;
-  latestWriteTimestamp = 0;
-  lastPktTimestamp = 0;
-  hi32Timestamp = 0;
-  isAligned = false;
-
-  //xtrx_stop(device, XTRX_TX);
-  //xtrx_stop(device, XTRX_RX);
-
-  xtrx_set_antenna(device, XTRX_TX_L);
-  xtrx_set_antenna(device, XTRX_RX_L);
-
-  xtrx_run_params_t params;
-  params.dir = XTRX_TRX;
-  params.nflags = (loopback) ? XTRX_RUN_DIGLOOPBACK : 0;
-
-  params.rx.chs = XTRX_CH_AB;
-  params.rx.flags = XTRX_RSP_SISO_MODE;
-  params.rx.hfmt = XTRX_IQ_INT16;
-  params.rx.wfmt = XTRX_WF_16;
-  params.rx.paketsize = 625 * rxsps;
-
-  params.tx.chs = XTRX_CH_AB;
-  params.tx.flags = XTRX_RSP_SISO_MODE;
-  params.tx.hfmt = XTRX_IQ_INT16;
-  params.tx.wfmt = XTRX_WF_16;
-  params.tx.paketsize = 625 * txsps;
-
-  if (loopback) {
-	params.tx.flags |= XTRX_RSP_SWAP_AB | XTRX_RSP_SWAP_IQ;
-  }
-
-  params.tx_repeat_buf = NULL;
-  params.rx_stream_start = initialReadTimestamp();
-
-  int res = xtrx_run_ex(device, &params);
-  if (res) {
-	  LOG(ALERT) << "XTRX start failed res: " << res;
-  } else {
-	  LOG(INFO) << "XTRX started";
-	  started = true;
-  }
-  return started;
-}
-
-bool XTRXDevice::stop() 
-{
-  if (started) {
-      int res = xtrx_stop(device, XTRX_TRX);
-      if (res) {
-          LOG(ALERT) << "XTRX stop failed res: " << res;
-      } else {
-          LOG(INFO) << "XTRX stopped";
-          started = false;
-      }
-  }
-  return !started;
-}
-
-TIMESTAMP XTRXDevice::initialWriteTimestamp()
-{
-	if (/*(iface == MULTI_ARFCN) || */(rxsps == txsps))
-		return initialReadTimestamp();
-	else
-		return initialReadTimestamp() * txsps;
-}
-
-double XTRXDevice::maxTxGain()
-{
-  return 30;
-}
-
-double XTRXDevice::minTxGain()
-{
-  return 0;
-}
-
-double XTRXDevice::maxRxGain()
-{
-  return 30;
-} 
-
-double XTRXDevice::minRxGain()
-{
-  return 0;
-}
-
-double XTRXDevice::setTxGain(double dB, size_t chan)
-{
-  if (chan) {
-    LOG(ALERT) << "Invalid channel " << chan;
-    return 0.0;
-  }
-  double actual = 0;
-  LOG(NOTICE) << "Setting TX gain to " << dB << " dB.";
-
-  int res = xtrx_set_gain(device, XTRX_CH_AB, XTRX_TX_PAD_GAIN, -10, &actual);
-  if (res) {
-    LOG(ERR) << "Error setting TX gain res: " << res;
-  }
-
-  return actual;
-}
-
-
-double XTRXDevice::setRxGain(double dB, size_t chan)
-{
-    if (chan) {
-      LOG(ALERT) << "Invalid channel " << chan;
-      return 0.0;
-    }
-    double actual = 0;
-    LOG(NOTICE) << "Setting RX gain to " << dB << " dB.";
-
-	int res = xtrx_set_gain(device, XTRX_CH_AB, XTRX_RX_LNA_GAIN, 25, &actual);
-    if (res) {
-      LOG(ERR) << "Error setting RX gain res: " << res;
-    }
-
-    return actual;
-}
-
-// NOTE: Assumes sequential reads
-int XTRXDevice::readSamples(std::vector<short *> &bufs, int len, bool *overrun,
-							TIMESTAMP timestamp, bool *underrun, unsigned *RSSI)
-{
-	if (!started)
-		return -1;
-
-	if (RSSI) {
-		*RSSI = 10; // TODO
-	}
-
-	struct xtrx_recv_ex_info ri;
-	ri.samples = len;
-	ri.buffer_count = bufs.size();
-	ri.buffers = (void* const*)&bufs[0];
-	ri.flags = 0;
-
-	int res = xtrx_recv_sync_ex(device, &ri);
-	if (res) {
-		LOG(ALERT) << "xtrx_recv_sync failed res " << res << " current TS " << timeRx << " req TS" << timestamp;
-		return -1;
-	}
-	timeRx += len;
-
-	// TODO: remove this
-	int i;
-	for (i = 0; i < len * 2; i++)
-			bufs[0][i] <<= 4;
-
-	if (underrun) {
-		*underrun = (ri.out_events & RCVEX_EVENT_FILLED_ZERO);
-	}
-	return len;
-
-}
-
-int XTRXDevice::writeSamples(std::vector<short *> &bufs, int len,
-                             bool *underrun, unsigned long long timestamp,
-                             bool isControl)
-{
-	if (!started)
-	  return 0;
-
-	xtrx_send_ex_info_t nfo;
-	nfo.buffers = (const void* const*)&bufs[0];
-	nfo.buffer_count = bufs.size();
-	nfo.flags = XTRX_TX_DONT_BUFFER;
-	nfo.samples = len;
-	nfo.ts = timestamp - time_tx_corr;
-
-	int res = xtrx_send_sync_ex(device, &nfo);
-	if (res != 0) {
-		LOG(ALERT) << "xtrx_send_sync_ex returned " << res << " len=" << len << " ts=" << timestamp;
-		return 0;
-	}
-
-	if (*underrun) {
-		*underrun = (nfo.out_flags & XTRX_TX_DISCARDED_TO);
-	}
-
-	return len;
-}
-
-bool XTRXDevice::updateAlignment(TIMESTAMP timestamp) 
-{
-	LOG(ALERT) << "Update Aligment " << timestamp;
-  return true;
-}
-
-bool XTRXDevice::setTxFreq(double wFreq, size_t chan)
-{
-    int res;
-    double actual = 0;
-
-    if (chan) {
-      LOG(ALERT) << "Invalid channel " << chan;
-      return false;
-    }
-
-    if ((res = xtrx_tune(device, XTRX_TUNE_TX_FDD, wFreq, &actual)) == 0) {
-      LOG(INFO) << "set RX: " << wFreq << std::endl
-                << "    actual freq: " << actual << std::endl;
-      return true;
-    }
-    else {
-      LOG(ALERT) << "set RX: " << wFreq << "failed (code: " << res << ")" << std::endl;
-      return false;
-    }
-}
-
-bool XTRXDevice::setRxFreq(double wFreq, size_t chan)
-{
-  int res;
-  double actual = 0;
-
-  if (chan) {
-    LOG(ALERT) << "Invalid channel " << chan;
-    return false;
-  }
-
-  if ((res = xtrx_tune(device, XTRX_TUNE_RX_FDD, wFreq, &actual)) == 0) {
-    LOG(INFO) << "set RX: " << wFreq << std::endl
-              << "    actual freq: " << actual << std::endl;
-    return true;
-  }
-  else {
-    LOG(ALERT) << "set RX: " << wFreq << "failed (code: " << res << ")" << std::endl;
-    return false;
-  }
-}
-
-RadioDevice *RadioDevice::make(size_t tx_sps, size_t rx_sps, InterfaceType type,
-                               size_t chans, double offset)
-{
-    return new XTRXDevice(tx_sps, rx_sps);
-}

Transceiver52M/XTRXDevice.h

@@ -1,166 +0,0 @@
-#ifndef _XTRX_DEVICE_H_
-#define _XTRX_DEVICE_H_
-
-#ifdef HAVE_CONFIG_H
-#include "config.h"
-#endif
-
-#include "radioDevice.h"
-
-#include <stdint.h>
-#include <sys/time.h>
-#include <string>
-#include <iostream>
-
-#include "Threads.h"
-#include <xtrx_api.h>
-
-class XTRXDevice: public RadioDevice {
-private:
-  int txsps;
-  int rxsps;
-  double actualTXSampleRate;	///< the actual XTRX sampling rate
-  double actualRXSampleRate;	///< the actual XTRX sampling rate
-  //unsigned int decimRate;	///< the XTRX decimation rate
-  //unsigned int interRate;	///< the XTRX decimation rate
-
-  unsigned long long samplesRead;	///< number of samples read from XTRX
-  unsigned long long samplesWritten;	///< number of samples sent to XTRX
-
-  bool started;			///< flag indicates XTRX has started
-
-  short *data;
-  unsigned long dataStart;
-  unsigned long dataEnd;
-  TIMESTAMP timeStart;
-  TIMESTAMP timeEnd;
-
-  TIMESTAMP timeRx;
-  bool isAligned;
-
-  Mutex writeLock;
-
-  short *currData;		///< internal data buffer when reading from XTRX
-  TIMESTAMP currTimestamp;	///< timestamp of internal data buffer
-  unsigned currLen;		///< size of internal data buffer
-
-  TIMESTAMP timestampOffset;       ///< timestamp offset b/w Tx and Rx blocks
-  TIMESTAMP latestWriteTimestamp;  ///< timestamp of most recent ping command
-  TIMESTAMP pingTimestamp;	   ///< timestamp of most recent ping response
-
-  unsigned long hi32Timestamp;
-  unsigned long lastPktTimestamp;
-
-  double rxGain;
-  bool loopback;
-
-#ifdef SWLOOPBACK 
-  short loopbackBuffer[1000000];
-  int loopbackBufferSize;
-  double samplePeriod; 
-
-  struct timeval startTime;
-  struct timeval lastReadTime;
-  bool   firstRead;
-#endif
-
-  xtrx_dev* device;
- public:
-
-  /** Object constructor */
-  XTRXDevice(size_t txsps, size_t rxsps);
-
-  ~XTRXDevice();
-
-  /** Instantiate the XTRX */
-  int open(const std::string &args, int ref, bool swap_channels);
-
-  /** Start the XTRX */
-  bool start();
-
-  /** Stop the XTRX */
-  bool stop();
-
-  /** Set priority not supported */
-  void setPriority(float prio = 0.5) { }
-
-  enum TxWindowType getWindowType() { return TX_WINDOW_FIXED; }
-
-  /**
-	Read samples from the XTRX.
-	@param buf preallocated buf to contain read result
-	@param len number of samples desired
-	@param overrun Set if read buffer has been overrun, e.g. data not being read fast enough
-	@param timestamp The timestamp of the first samples to be read
-	@param underrun Set if XTRX does not have data to transmit, e.g. data not being sent fast enough
-	@param RSSI The received signal strength of the read result
-	@return The number of samples actually read
-  */
-  int readSamples(std::vector<short *> &buf, int len, bool *overrun,
-                  TIMESTAMP timestamp = 0xffffffff, bool *underrun = NULL,
-                  unsigned *RSSI = NULL);
-  /**
-        Write samples to the XTRX.
-        @param buf Contains the data to be written.
-        @param len number of samples to write.
-        @param underrun Set if XTRX does not have data to transmit, e.g. data not being sent fast enough
-        @param timestamp The timestamp of the first sample of the data buffer.
-        @param isControl Set if data is a control packet, e.g. a ping command
-        @return The number of samples actually written
-  */
-  int writeSamples(std::vector<short *> &bufs, int len, bool *underrun,
-                   TIMESTAMP timestamp = 0xffffffff, bool isControl = false);
-
-  /** Update the alignment between the read and write timestamps */
-  bool updateAlignment(TIMESTAMP timestamp);
-
-  /** Set the transmitter frequency */
-  bool setTxFreq(double wFreq, size_t chan = 0);
-
-  /** Set the receiver frequency */
-  bool setRxFreq(double wFreq, size_t chan = 0);
-
-  /** Returns the starting write Timestamp*/
-  TIMESTAMP initialWriteTimestamp(void);
-
-  /** Returns the starting read Timestamp*/
-  TIMESTAMP initialReadTimestamp(void) { return 20000;}
-
-  /** returns the full-scale transmit amplitude **/
-  double fullScaleInputValue() {return (double) 32767*0.7;}
-
-  /** returns the full-scale receive amplitude **/
-  double fullScaleOutputValue() {return (double) 32767;}
-
-  /** sets the receive chan gain, returns the gain setting **/
-  double setRxGain(double dB, size_t chan = 0);
-
-  /** get the current receive gain */
-  double getRxGain(size_t chan = 0) { return rxGain; }
-
-  /** return maximum Rx Gain **/
-  double maxRxGain(void);
-
-  /** return minimum Rx Gain **/
-  double minRxGain(void);
-
-  /** sets the transmit chan gain, returns the gain setting **/
-  double setTxGain(double dB, size_t chan = 0);
-
-  /** return maximum Tx Gain **/
-  double maxTxGain(void);
-
-  /** return minimum Rx Gain **/
-  double minTxGain(void);
-
-  /** Return internal status values */
-  inline double getTxFreq(size_t chan = 0) { return 0; }
-  inline double getRxFreq(size_t chan = 0) { return 0; }
-  inline double getSampleRate() { return actualTXSampleRate; }
-  inline double numberRead() { return samplesRead; }
-  inline double numberWritten() { return samplesWritten; }
-
-};
-
-#endif // _XTRX_DEVICE_H_
-

Transceiver52M/arm/convert.c

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

Transceiver52M/arm/convolve.c

@@ -58,13 +58,6 @@ 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,15 +1,7 @@
 #ifndef _CONVERT_H_
 #define _CONVERT_H_
 
-void convert_float_short(short *out, const float *in, float scale, int len);
-
-void convert_short_float(float *out, const short *in, int len);
-
-void base_convert_float_short(short *out, const float *in,
-			      float scale, int len);
-
-void base_convert_short_float(float *out, const short *in, int len);
-
-void convert_init(void);
+void convert_float_short(short *out, float *in, float scale, int len);
+void convert_short_float(float *out, short *in, int len);
 
 #endif /* _CONVERT_H_ */

Transceiver52M/common/convert_base.c

@@ -1,34 +0,0 @@
-/*
- * 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,30 +3,28 @@
 
 void *convolve_h_alloc(int num);
 
-int convolve_real(const float *x, int x_len,
-		  const float *h, int h_len,
+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_complex(const float *x, int x_len,
-		     const float *h, int h_len,
+int convolve_complex(float *x, int x_len,
+		     float *h, int h_len,
 		     float *y, int y_len,
 		     int start, int len,
 		     int step, int offset);
 
-int base_convolve_real(const float *x, int x_len,
-		       const float *h, int h_len,
+int base_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 base_convolve_complex(const float *x, int x_len,
-			  const float *h, int h_len,
+int base_convolve_complex(float *x, int x_len,
+			  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(const float *x, const float *h, float *y)
+static void mac_real(float *x, 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(const float *x, const float *h, float *y)
+static void mac_cmplx(float *x, 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(const float *x, const float *h, float *y,
+static void mac_real_vec_n(float *x, 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(const float *x, const float *h, float *y,
 }
 
 /* Base vector complex-complex multiply and accumulate */
-static void mac_cmplx_vec_n(const float *x, const float *h, float *y,
+static void mac_cmplx_vec_n(float *x, 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(const float *x, const float *h, float *y,
 }
 
 /* Base complex-real convolution */
-int _base_convolve_real(const float *x, int x_len,
-			const float *h, int h_len,
+int _base_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)
@@ -73,8 +73,8 @@ int _base_convolve_real(const float *x, int x_len,
 }
 
 /* Base complex-complex convolution */
-int _base_convolve_complex(const float *x, int x_len,
-			   const float *h, int h_len,
+int _base_convolve_complex(float *x, int x_len,
+			   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(const float *x, int x_len,
-		       const float *h, int h_len,
+int base_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)
@@ -128,8 +128,8 @@ int base_convolve_real(const float *x, int x_len,
 }
 
 /* API: Non-aligned (no SSE) complex-complex */
-int base_convolve_complex(const float *x, int x_len,
-			  const float *h, int h_len,
+int base_convolve_complex(float *x, int x_len,
+			  float *h, int h_len,
 			  float *y, int y_len,
 			  int start, int len,
 			  int step, int offset)

Transceiver52M/common/fft.c

@@ -1,112 +0,0 @@
-/*
- * 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

@@ -1,13 +0,0 @@
-#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.cpp

@@ -27,65 +27,91 @@
 #include <signal.h>
 #include <stdlib.h>
 #include <unistd.h>
-#include <sched.h>
 
 #include <GSMCommon.h>
 #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.
+ *     downsampled to 1 sps. Default to 4 sps for all cases except for
+ *     ARM and non-SIMD enabled architectures.
  */
-#define DEFAULT_TX_SPS		4
+#if defined(HAVE_NEON) || !defined(HAVE_SSE3)
+#define DEFAULT_SPS		1
+#else
+#define DEFAULT_SPS		4
+#endif
 
-/*
- * 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.
+/* 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.
  */
-#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 {
 	std::string log_level;
-	std::string local_addr;
-	std::string remote_addr;
+	std::string addr;
 	std::string dev_args;
 	unsigned port;
-	unsigned tx_sps;
-	unsigned rx_sps;
+	unsigned sps;
 	unsigned chans;
 	unsigned rtsc;
-	unsigned rach_delay;
 	bool extref;
-	bool gpsref;
 	Transceiver::FillerType filler;
-	bool mcbts;
+	bool diversity;
 	double offset;
 	double rssi_offset;
 	bool swap_channels;
-	bool edge;
-	int sched_rr;
 };
 
 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
@@ -95,23 +121,48 @@ volatile bool gshutdown = false;
  */
 bool trx_setup_config(struct trx_config *config)
 {
-	std::string refstr, fillstr, divstr, mcstr, edgestr;
+	std::string refstr, fillstr, divstr;
 
-	if (config->mcbts && config->chans > 5) {
-		std::cout << "Unsupported number of channels" << std::endl;
+	if (!testConfig())
 		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;
 	}
 
-	edgestr = config->edge ? "Enabled" : "Disabled";
-	mcstr = config->mcbts ? "Enabled" : "Disabled";
+	if (config->addr == "") {
+		if (gConfig.defines("TRX.IP"))
+			config->addr = gConfig.getStr("TRX.IP");
+		else
+			config->addr = DEFAULT_TRX_IP;
+	}
 
-	if (config->extref)
-		refstr = "External";
-	else if (config->gpsref)
-		refstr = "GPS";
-	else
-		refstr = "Internal";
+	if (!config->extref) {
+		if (gConfig.defines("TRX.Reference"))
+			config->extref = gConfig.getNum("TRX.Reference");
+		else
+			config->extref = DEFAULT_EXTREF;
+	}
 
+	if (!config->diversity) {
+		if (gConfig.defines("TRX.Diversity"))
+			config->diversity = gConfig.getNum("TRX.Diversity");
+		else
+			config->diversity = DEFAULT_DIVERSITY;
+	}
+
+	/* Diversity only supported on 2 channels */
+	if (config->diversity)
+		config->chans = 2;
+
+	refstr = config->extref ? "Enabled" : "Disabled";
+	divstr = config->diversity ? "Enabled" : "Disabled";
 	switch (config->filler) {
 	case Transceiver::FILLER_DUMMY:
 		fillstr = "Dummy bursts";
@@ -119,15 +170,9 @@ bool trx_setup_config(struct trx_config *config)
 	case Transceiver::FILLER_ZERO:
 		fillstr = "Disabled";
 		break;
-	case Transceiver::FILLER_NORM_RAND:
+	case Transceiver::FILLER_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;
 	}
 
 	std::ostringstream ost("");
@@ -135,15 +180,12 @@ bool trx_setup_config(struct trx_config *config)
 	ost << "   Log Level............... " << config->log_level << std::endl;
 	ost << "   Device args............. " << config->dev_args << std::endl;
 	ost << "   TRX Base Port........... " << config->port << std::endl;
-	ost << "   TRX Address............. " << config->local_addr << std::endl;
-	ost << "   GSM Core Address........." << config->remote_addr << std::endl;
+	ost << "   TRX Address............. " << config->addr << std::endl;
 	ost << "   Channels................ " << config->chans << 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 << "   Samples-per-Symbol...... " << config->sps << std::endl;
+	ost << "   External Reference...... " << refstr << std::endl;
 	ost << "   C0 Filler Table......... " << fillstr << std::endl;
-	ost << "   Multi-Carrier........... " << mcstr << std::endl;
+	ost << "   Diversity............... " << divstr << 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;
@@ -166,22 +208,17 @@ RadioInterface *makeRadioInterface(struct trx_config *config,
 
 	switch (type) {
 	case RadioDevice::NORMAL:
-		radio = new RadioInterface(usrp, config->tx_sps,
-					   config->rx_sps, config->chans);
+		radio = new RadioInterface(usrp, config->sps, config->chans);
 		break;
-#ifndef NO_RESAMPLER
 	case RadioDevice::RESAMP_64M:
 	case RadioDevice::RESAMP_100M:
-		radio = new RadioInterfaceResamp(usrp, config->tx_sps,
-						 config->rx_sps);
+		radio = new RadioInterfaceResamp(usrp,
+						 config->sps, config->chans);
 		break;
-#endif
-#ifndef NO_MULTIARFCN
-	case RadioDevice::MULTI_ARFCN:
-		radio = new RadioInterfaceMulti(usrp, config->tx_sps,
-						config->rx_sps, config->chans);
+	case RadioDevice::DIVERSITY:
+		radio = new RadioInterfaceDiversity(usrp,
+						    config->sps, config->chans);
 		break;
-#endif
 	default:
 		LOG(ALERT) << "Unsupported radio interface configuration";
 		return NULL;
@@ -206,12 +243,9 @@ Transceiver *makeTransceiver(struct trx_config *config, RadioInterface *radio)
 	Transceiver *trx;
 	VectorFIFO *fifo;
 
-	trx = new Transceiver(config->port, config->local_addr.c_str(),
-			      config->remote_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)) {
+	trx = new Transceiver(config->port, config->addr.c_str(), config->sps,
+		config->chans, GSM::Time(3,0), radio, config->rssi_offset);
+	if (!trx->init(config->filler, config->rtsc)) {
 		LOG(ALERT) << "Failed to initialize transceiver";
 		delete trx;
 		return NULL;
@@ -255,22 +289,16 @@ static void print_help()
 		"  -a    UHD device args\n"
 		"  -l    Logging level (%s)\n"
 		"  -i    IP address of GSM core\n"
-		"  -j    IP address of osmo-trx\n"
 		"  -p    Base port number\n"
-		"  -e    Enable EDGE receiver\n"
-		"  -m    Enable multi-ARFCN transceiver (default=disabled)\n"
+		"  -d    Enable dual channel diversity receiver\n"
 		"  -x    Enable external 10 MHz reference\n"
-		"  -g    Enable GPSDO reference\n"
-		"  -s    Tx samples-per-symbol (1 or 4)\n"
-		"  -b    Rx samples-per-symbol (1 or 4)\n"
+		"  -s    Samples-per-symbol (1 or 4)\n"
 		"  -c    Number of ARFCN channels (default=1)\n"
 		"  -f    Enable C0 filler table\n"
 		"  -o    Set baseband frequency offset (default=auto)\n"
-		"  -r    Random Normal Burst test mode with TSC\n"
-		"  -A    Random Access Burst test mode with delay\n"
+		"  -r    Random burst test mode with TSC\n"
 		"  -R    RSSI to dBm offset in dB (default=0)\n"
-		"  -S    Swap channels (UmTRX only)\n"
-		"  -t    SCHED_RR real-time priority (1..32)\n",
+		"  -S    Swap channels (UmTRX only)\n",
 		"EMERG, ALERT, CRT, ERR, WARNING, NOTICE, INFO, DEBUG");
 }
 
@@ -278,26 +306,18 @@ static void handle_options(int argc, char **argv, struct trx_config *config)
 {
 	int option;
 
-	config->log_level = "NOTICE";
-	config->local_addr = DEFAULT_TRX_IP;
-	config->remote_addr = DEFAULT_TRX_IP;
-	config->port = DEFAULT_TRX_PORT;
-	config->tx_sps = DEFAULT_TX_SPS;
-	config->rx_sps = DEFAULT_RX_SPS;
+	config->port = 0;
+	config->sps = DEFAULT_SPS;
 	config->chans = DEFAULT_CHANS;
 	config->rtsc = 0;
-	config->rach_delay = 0;
 	config->extref = false;
-	config->gpsref = false;
 	config->filler = Transceiver::FILLER_ZERO;
-	config->mcbts = false;
+	config->diversity = false;
 	config->offset = 0.0;
 	config->rssi_offset = 0.0;
 	config->swap_channels = false;
-	config->edge = false;
-	config->sched_rr = -1;
 
-	while ((option = getopt(argc, argv, "ha:l:i:j:p:c:dmxgfo:s:b:r:A:R:Set:")) != -1) {
+	while ((option = getopt(argc, argv, "ha:l:i:p:c:dxfo:s:r:R:S")) != -1) {
 		switch (option) {
 		case 'h':
 			print_help();
@@ -310,10 +330,7 @@ static void handle_options(int argc, char **argv, struct trx_config *config)
 			config->log_level = optarg;
 			break;
 		case 'i':
-			config->remote_addr = optarg;
-			break;
-		case 'j':
-			config->local_addr = optarg;
+			config->addr = optarg;
 			break;
 		case 'p':
 			config->port = atoi(optarg);
@@ -321,15 +338,12 @@ static void handle_options(int argc, char **argv, struct trx_config *config)
 		case 'c':
 			config->chans = atoi(optarg);
 			break;
-		case 'm':
-			config->mcbts = true;
+		case 'd':
+			config->diversity = true;
 			break;
 		case 'x':
 			config->extref = true;
 			break;
-		case 'g':
-			config->gpsref = true;
-			break;
 		case 'f':
 			config->filler = Transceiver::FILLER_DUMMY;
 			break;
@@ -337,18 +351,11 @@ static void handle_options(int argc, char **argv, struct trx_config *config)
 			config->offset = atof(optarg);
 			break;
 		case 's':
-			config->tx_sps = atoi(optarg);
-			break;
-		case 'b':
-			config->rx_sps = atoi(optarg);
+			config->sps = atoi(optarg);
 			break;
 		case 'r':
 			config->rtsc = atoi(optarg);
-			config->filler = Transceiver::FILLER_NORM_RAND;
-			break;
-		case 'A':
-			config->rach_delay = atoi(optarg);
-			config->filler = Transceiver::FILLER_ACCESS_RAND;
+			config->filler = Transceiver::FILLER_RAND;
 			break;
 		case 'R':
 			config->rssi_offset = atof(optarg);
@@ -356,113 +363,35 @@ static void handle_options(int argc, char **argv, struct trx_config *config)
 		case 'S':
 			config->swap_channels = true;
 			break;
-		case 'e':
-			config->edge = true;
-			break;
-		case 't':
-			config->sched_rr = atoi(optarg);
-			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_NORM_RAND))
-		config->filler = Transceiver::FILLER_EDGE_RAND;
-
-	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->sps != 1) && (config->sps != 4)) {
+		printf("Unsupported samples-per-symbol %i\n\n", config->sps);
+		print_help();
+		exit(0);
 	}
 
 	if (config->rtsc > 7) {
 		printf("Invalid training sequence %i\n\n", config->rtsc);
-		goto bad_config;
+		print_help();
+		exit(0);
 	}
-
-	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);
-}
-
-static int set_sched_rr(int prio)
-{
-	struct sched_param param;
-	int rc;
-	memset(&param, 0, sizeof(param));
-	param.sched_priority = prio;
-	printf("Setting SCHED_RR priority(%d)\n", param.sched_priority);
-	rc = sched_setscheduler(getpid(), SCHED_RR, &param);
-	if (rc != 0) {
-		std::cerr << "Config: Setting SCHED_RR failed" << std::endl;
-		return -1;
-	}
-	return 0;
 }
 
 int main(int argc, char *argv[])
 {
-	int type, chans, ref;
+	int type, chans;
 	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");
-#ifdef HAVE___BUILTIN_CPU_SUPPORTS
-	if (__builtin_cpu_supports("sse3"))
-		printf(" and supported by CPU\n");
-	else
-		printf(", but not supported by CPU\n");
-#else
-	printf(", but runtime SIMD detection disabled\n");
-#endif
-#endif
-
-#ifdef HAVE_SSE4_1
-	printf("Info: SSE4.1 support compiled in");
-#ifdef HAVE___BUILTIN_CPU_SUPPORTS
-	if (__builtin_cpu_supports("sse4.1"))
-		printf(" and supported by CPU\n");
-	else
-		printf(", but not supported by CPU\n");
-#else
-	printf(", but runtime SIMD detection disabled\n");
-#endif
-#endif
-
-	convolve_init();
-	convert_init();
-
 	handle_options(argc, argv, &config);
 
-	if (config.sched_rr != -1) {
-		if (set_sched_rr(config.sched_rr) < 0)
-			return EXIT_FAILURE;
-	}
-
 	setup_signal_handlers();
 
 	/* Check database sanity */
@@ -476,19 +405,9 @@ int main(int argc, char *argv[])
 	srandom(time(NULL));
 
 	/* Create the low level device object */
-	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);
+	usrp = RadioDevice::make(config.sps, config.chans,
+				 config.diversity, config.offset);
+	type = usrp->open(config.dev_args, config.extref, config.swap_channels);
 	if (type < 0) {
 		LOG(ALERT) << "Failed to create radio device" << std::endl;
 		goto shutdown;

Transceiver52M/radioBuffer.cpp

@@ -1,228 +0,0 @@
-/*
- * 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

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

Transceiver52M/radioDevice.h

@@ -22,8 +22,7 @@
 #include "config.h"
 #endif
 
-#define GSMRATE       (1625e3/6)
-#define MCBTS_SPACING  800000.0
+#define GSMRATE       1625e3/6
 
 /** a 64-bit virtual timestamp for radio data */
 typedef unsigned long long TIMESTAMP;
@@ -36,24 +35,13 @@ class RadioDevice {
   enum TxWindowType { TX_WINDOW_USRP1, TX_WINDOW_FIXED };
 
   /* Radio interface types */
-  enum InterfaceType {
-    NORMAL,
-    RESAMP_64M,
-    RESAMP_100M,
-    MULTI_ARFCN,
-  };
+  enum RadioInterfaceType { NORMAL, RESAMP_64M, RESAMP_100M, DIVERSITY };
 
-  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);
+  static RadioDevice *make(size_t sps, size_t chans = 1,
+                           bool diversity = false, double offset = 0.0);
 
   /** Initialize the USRP */
-  virtual int open(const std::string &args, int ref, bool swap_channels)=0;
+  virtual int open(const std::string &args = "", bool extref = false, bool swap_channels = false)=0;
 
   virtual ~RadioDevice() { }
 

Transceiver52M/radioInterface.cpp

@@ -1,23 +1,26 @@
 /*
- * 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.
- */
+* 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/>.
+
+*/
 
 #include "radioInterface.h"
 #include "Resampler.h"
@@ -30,11 +33,12 @@ extern "C" {
 #define CHUNK		625
 #define NUMCHUNKS	4
 
-RadioInterface::RadioInterface(RadioDevice *wRadio, size_t tx_sps,
-                               size_t rx_sps, size_t chans,
+RadioInterface::RadioInterface(RadioDevice *wRadio,
+                               size_t sps, size_t chans, size_t diversity,
                                int wReceiveOffset, GSM::Time wStartTime)
-  : mRadio(wRadio), mSPSTx(tx_sps), mSPSRx(rx_sps), mChans(chans),
-    underrun(false), overrun(false), receiveOffset(wReceiveOffset), mOn(false)
+  : mRadio(wRadio), mSPSTx(sps), mSPSRx(1), mChans(chans), mMIMO(diversity),
+    sendCursor(0), recvCursor(0), underrun(false), overrun(false),
+    receiveOffset(wReceiveOffset), mOn(false)
 {
   mClock.set(wStartTime);
 }
@@ -46,7 +50,7 @@ RadioInterface::~RadioInterface(void)
 
 bool RadioInterface::init(int type)
 {
-  if ((type != RadioDevice::NORMAL) || !mChans) {
+  if ((type != RadioDevice::NORMAL) || (mMIMO > 1) || !mChans) {
     LOG(ALERT) << "Invalid configuration";
     return false;
   }
@@ -61,20 +65,33 @@ bool RadioInterface::init(int type)
   powerScaling.resize(mChans);
 
   for (size_t i = 0; i < mChans; i++) {
-    sendBuffer[i] = new RadioBuffer(NUMCHUNKS, CHUNK * mSPSTx, 0, true);
-    recvBuffer[i] = new RadioBuffer(NUMCHUNKS, CHUNK * mSPSRx, 0, false);
+    sendBuffer[i] = new signalVector(CHUNK * mSPSTx);
+    recvBuffer[i] = new signalVector(NUMCHUNKS * CHUNK * mSPSRx);
 
-    convertSendBuffer[i] = new short[CHUNK * mSPSTx * 2];
-    convertRecvBuffer[i] = new short[CHUNK * mSPSRx * 2];
-
-    powerScaling[i] = 1.0;
+    convertSendBuffer[i] = new short[sendBuffer[i]->size() * 2];
+    convertRecvBuffer[i] = new short[recvBuffer[i]->size() * 2];
   }
 
+  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);
@@ -113,26 +130,35 @@ int RadioInterface::setPowerAttenuation(int atten, size_t chan)
 }
 
 int RadioInterface::radioifyVector(signalVector &wVector,
-                                   size_t chan, bool zero)
+				   float *retVector,
+				   bool zero)
 {
-  if (zero)
-    sendBuffer[chan]->zero(wVector.size());
-  else
-    sendBuffer[chan]->write((float *) wVector.begin(), wVector.size());
+  if (zero) {
+    memset(retVector, 0, wVector.size() * 2 * sizeof(float));
+    return wVector.size();
+  }
+
+  memcpy(retVector, wVector.begin(), wVector.size() * 2 * sizeof(float));
 
   return wVector.size();
 }
 
-int RadioInterface::unRadioifyVector(signalVector *newVector, size_t chan)
+int RadioInterface::unRadioifyVector(float *floatVector,
+				     signalVector& newVector)
 {
-  if (newVector->size() > recvBuffer[chan]->getAvailSamples()) {
+  signalVector::iterator itr = newVector.begin();
+
+  if (newVector.size() > recvCursor) {
     LOG(ALERT) << "Insufficient number of samples in receive buffer";
     return -1;
   }
 
-  recvBuffer[chan]->read((float *) newVector->begin(), newVector->size());
+  for (size_t i = 0; i < newVector.size(); i++) {
+    *itr++ = Complex<float>(floatVector[2 * i + 0],
+			    floatVector[2 * i + 1]);
+  }
 
-  return newVector->size();
+  return newVector.size();
 }
 
 bool RadioInterface::tuneTx(double freq, size_t chan)
@@ -159,10 +185,8 @@ bool RadioInterface::start()
   if (!mRadio->start())
     return false;
 
-  for (size_t i = 0; i < mChans; i++) {
-    sendBuffer[i]->reset();
-    recvBuffer[i]->reset();
-  }
+  recvCursor = 0;
+  sendCursor = 0;
 
   writeTimestamp = mRadio->initialWriteTimestamp();
   readTimestamp = mRadio->initialReadTimestamp();
@@ -213,10 +237,14 @@ void RadioInterface::driveTransmitRadio(std::vector<signalVector *> &bursts,
   if (!mOn)
     return;
 
-  for (size_t i = 0; i < mChans; i++)
-    radioifyVector(*bursts[i], i, zeros[i]);
+  for (size_t i = 0; i < mChans; i++) {
+    radioifyVector(*bursts[i],
+                   (float *) (sendBuffer[i]->begin() + sendCursor), zeros[i]);
+  }
 
-  while (pushBuffer());
+  sendCursor += bursts[0]->size();
+
+  pushBuffer();
 }
 
 bool RadioInterface::driveReceiveRadio()
@@ -231,14 +259,10 @@ bool RadioInterface::driveReceiveRadio()
   GSM::Time rcvClock = mClock.get();
   rcvClock.decTN(receiveOffset);
   unsigned tN = rcvClock.TN();
-  int recvSz = recvBuffer[0]->getAvailSamples();
+  int recvSz = recvCursor;
+  int readSz = 0;
   const int symbolsPerSlot = gSlotLen + 8;
-  int burstSize;
-
-  if (mSPSRx == 4)
-    burstSize = 625;
-  else
-    burstSize = symbolsPerSlot + (tN % 4 == 0);
+  int burstSize = (symbolsPerSlot + (tN % 4 == 0)) * mSPSRx;
 
   /* 
    * Pre-allocate head room for the largest correlation size
@@ -252,8 +276,13 @@ bool RadioInterface::driveReceiveRadio()
    */
   while (recvSz > burstSize) {
     for (size_t i = 0; i < mChans; i++) {
-      burst = new radioVector(rcvClock, burstSize, head);
-      unRadioifyVector(burst->getVector(), 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));
+      }
 
       if (mReceiveFIFO[i].size() < 32)
         mReceiveFIFO[i].write(burst);
@@ -263,12 +292,22 @@ bool RadioInterface::driveReceiveRadio()
 
     mClock.incTN();
     rcvClock.incTN();
+    readSz += burstSize;
     recvSz -= burstSize;
 
     tN = rcvClock.TN();
 
-    if (mSPSRx != 4)
-      burstSize = (symbolsPerSlot + (tN % 4 == 0)) * mSPSRx;
+    burstSize = (symbolsPerSlot + (tN % 4 == 0)) * mSPSRx;
+  }
+
+  if (readSz > 0) {
+    for (size_t i = 0; i < recvBuffer.size(); i++) {
+      memmove(recvBuffer[i]->begin(),
+              recvBuffer[i]->begin() + readSz,
+              (recvCursor - readSz) * 2 * sizeof(float));
+    }
+
+    recvCursor -= readSz;
   }
 
   return true;
@@ -292,66 +331,74 @@ VectorFIFO* RadioInterface::receiveFIFO(size_t chan)
 
 double RadioInterface::setRxGain(double dB, size_t chan)
 {
-  return mRadio->setRxGain(dB, chan);
+  if (mRadio)
+    return mRadio->setRxGain(dB, chan);
+  else
+    return -1;
 }
 
 double RadioInterface::getRxGain(size_t chan)
 {
-  return mRadio->getRxGain(chan);
+  if (mRadio)
+    return mRadio->getRxGain(chan);
+  else
+    return -1;
 }
 
 /* Receive a timestamped chunk from the device */
 void RadioInterface::pullBuffer()
 {
   bool local_underrun;
-  size_t numRecv, segmentLen = recvBuffer[0]->getSegmentLen();
+  int num_recv;
+  float *output;
 
-  if (recvBuffer[0]->getFreeSegments() <= 0)
+  if (recvCursor > recvBuffer[0]->size() - CHUNK)
     return;
 
   /* Outer buffer access size is fixed */
-  numRecv = mRadio->readSamples(convertRecvBuffer,
-                                segmentLen,
-                                &overrun,
-                                readTimestamp,
-                                &local_underrun);
-
-  if (numRecv != segmentLen) {
-          LOG(ALERT) << "Receive error " << numRecv;
+  num_recv = mRadio->readSamples(convertRecvBuffer,
+                                 CHUNK,
+                                 &overrun,
+                                 readTimestamp,
+                                 &local_underrun);
+  if (num_recv != CHUNK) {
+          LOG(ALERT) << "Receive error " << num_recv;
           return;
   }
 
   for (size_t i = 0; i < mChans; i++) {
-    convert_short_float(recvBuffer[i]->getWriteSegment(),
-			convertRecvBuffer[i],
-			segmentLen * 2);
+    output = (float *) (recvBuffer[i]->begin() + recvCursor);
+    convert_short_float(output, convertRecvBuffer[i], 2 * num_recv);
   }
 
   underrun |= local_underrun;
-  readTimestamp += numRecv;
+
+  readTimestamp += num_recv;
+  recvCursor += num_recv;
 }
 
 /* Send timestamped chunk to the device with arbitrary size */
-bool RadioInterface::pushBuffer()
+void RadioInterface::pushBuffer()
 {
-  size_t numSent, segmentLen = sendBuffer[0]->getSegmentLen();
+  int num_sent;
 
-  if (sendBuffer[0]->getAvailSegments() < 1)
-    return false;
+  if (sendCursor < CHUNK)
+    return;
+
+  if (sendCursor > sendBuffer[0]->size())
+    LOG(ALERT) << "Send buffer overflow";
 
   for (size_t i = 0; i < mChans; i++) {
     convert_float_short(convertSendBuffer[i],
-                        (float *) sendBuffer[i]->getReadSegment(),
-                        powerScaling[i],
-                        segmentLen * 2);
+                        (float *) sendBuffer[i]->begin(),
+                        powerScaling[i], 2 * sendCursor);
   }
 
-  /* Send the all samples in the send buffer */
-  numSent = mRadio->writeSamples(convertSendBuffer,
-                                 segmentLen,
-                                 &underrun,
-                                 writeTimestamp);
-  writeTimestamp += numSent;
-
-  return true;
+  /* Send the all samples in the send buffer */ 
+  num_sent = mRadio->writeSamples(convertSendBuffer,
+                                  sendCursor,
+                                  &underrun,
+                                  writeTimestamp);
+  writeTimestamp += num_sent;
+  sendCursor = 0;
 }

Transceiver52M/radioInterface.h

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

Transceiver52M/radioInterfaceDiversity.cpp

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

Transceiver52M/radioInterfaceMulti.cpp

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

Transceiver52M/sigProcLib.h

@@ -20,21 +20,15 @@
 #include "BitVector.h"
 #include "signalVector.h"
 
-/* Burst lengths */
-#define NORMAL_BURST_NBITS    148
-#define EDGE_BURST_NBITS      444
-#define EDGE_BURST_NSYMS      (EDGE_BURST_NBITS / 3)
-
-/** 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
+/** Convolution type indicator */
+enum ConvType {
+  START_ONLY,
+  NO_DELAY,
+  CUSTOM,
+  UNDEFINED,
 };
 
-enum SignalError {
+enum signalError {
   SIGERR_NONE,
   SIGERR_BOUNDS,
   SIGERR_CLIP,
@@ -42,47 +36,112 @@ enum SignalError {
   SIGERR_INTERNAL,
 };
 
-/*
- * Burst detection threshold
- *
- * Decision threshold value for burst gating on peak-to-average value of
- * correlated synchronization sequences. Lower values pass more bursts up
- * to upper layers but will increase the false detection rate.
- */
-#define BURST_THRESH    4.0
+/** Convert a linear number to a dB value */
+float dB(float x);
+
+/** Convert a dB value into a linear value */
+float dBinv(float x);
+
+/** Compute the energy of a vector */
+float vectorNorm2(const signalVector &x);
+
+/** Compute the average power of a vector */
+float vectorPower(const signalVector &x);
 
 /** Setup the signal processing library */
-bool sigProcLibSetup();
+bool sigProcLibSetup(int sps);
 
 /** Destroy the signal processing library */
 void sigProcLibDestroy(void);
 
-/** Operate soft slicer on a soft-bit vector */
-bool vectorSlicer(SoftVector *x);
+/** 
+ 	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.
+*/
+signalVector* frequencyShift(signalVector *y,
+			     signalVector *x,
+			     float freq = 0.0,
+			     float startPhase = 0.0,
+			     float *finalPhase=NULL);
+
+/** 
+        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,
+                        bool bReversedConjugated = false,
+			unsigned startIx = 0,
+			unsigned len = 0);
+
+/** Operate soft slicer on real-valued portion of vector */ 
+bool vectorSlicer(signalVector *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);
+/** Sinc function */
+float sinc(float x);
 
-/** Generate a EDGE burst with random payload - 4 SPS (625 samples) only */
-signalVector *generateEdgeBurst(int tsc);
+/** Delay a vector */
+signalVector *delayVector(signalVector *in, signalVector *out, float delay);
 
-/** Generate an empty burst - 4 or 1 SPS */
-signalVector *generateEmptyBurst(int sps, int tn);
+/** Add two vectors in-place */
+bool addVector(signalVector &x,
+	       signalVector &y);
 
-/** Generate a normal GSM burst with random payload - 4 or 1 SPS */
-signalVector *genRandNormalBurst(int tsc, int sps, int tn);
+/** Multiply two vectors in-place*/
+bool multVector(signalVector &x,
+                signalVector &y);
 
-/** Generate an access GSM burst with random payload - 4 or 1 SPS */
-signalVector *genRandAccessBurst(int delay, int sps, int tn);
+/** Generate a vector of gaussian noise */
+signalVector *gaussianNoise(int length,
+                            float variance = 1.0,
+                            complex mean = complex(0.0));
 
-/** Generate a dummy GSM burst - 4 or 1 SPS */
-signalVector *generateDummyBurst(int sps, int tn);
+/**
+	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);
+
+/**
+	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);
 
 /**
         Apply a scalar to a vector.
@@ -90,40 +149,130 @@ signalVector *generateDummyBurst(int sps, int tn);
         @param scale The scalar.
 */
 void scaleVector(signalVector &x,
-                 complex scale);
+		 complex scale);
 
 /**
-        Rough energy estimator.
-        @param rxBurst A GSM burst.
-        @param windowLength The number of burst samples used to compute burst energy
-        @return The average power of the received burst.
+        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.
 */
-float energyDetect(const signalVector &rxBurst,
-                   unsigned windowLength);
+bool generateMidamble(int sps, int tsc);
 /**
-        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.
+        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);
+
+/**
+        Energy detector, checks to see if received burst energy is above a threshold.
+        @param rxBurst The received GSM burst of interest.
+        @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.
+*/
+bool energyDetect(signalVector &rxBurst,
+		  unsigned windowLength,
+                  float detectThreshold,
+                  float *avgPwr = NULL);
+
+/**
+        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.
+        @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
+*/
+int detectRACHBurst(signalVector &rxBurst,
+                    float detectThreshold,
+                    int sps,
+                    complex &amplitude,
+                    float &TOA);
+
+/**
+        Normal burst correlator, detector, channel estimator.
+        @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 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
+        @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
 */
-int detectAnyBurst(const signalVector &burst,
-                   unsigned tsc,
-                   float threshold,
-                   int sps,
-                   CorrType type,
-                   complex &amp,
-                   float &toa,
-                   unsigned max_toa);
+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);
 
-/** Demodulate burst basde on type and output soft bits */
-SoftVector *demodAnyBurst(const signalVector &burst, int sps,
-                          complex amp, float toa, CorrType type);
+/**
+	Decimate a vector.
+        @param wVector The vector of interest.
+        @param factor Decimation factor.
+        @return The decimated signal vector.
+*/
+signalVector *decimateVector(signalVector &wVector, size_t factor);
+
+/**
+        Applies time of arrival to align burst with bit positions
+        @param rxBurst The burst to be aligned
+        @param channel The amplitude estimate of the received burst.
+        @param TOA The time-of-arrival of the received burst.
+        @return The aligned burst.
+*/
+signalVector *alignBurst(signalVector &rxBurst, complex channel, float TOA);
+
+/**
+        Demodulates a received burst using a soft-slicer.
+        @param rxBurst The burst to be demodulated.
+        @param sps The number of samples per GSM symbol.
+        @return The demodulated bit sequence.
+*/
+SoftVector *demodulateBurst(signalVector &rxBurst, int sps);
+
+/**
+	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.
+*/
+bool designDFE(signalVector &channelResponse,
+	       float SNRestimate,
+	       int Nf,
+	       signalVector **feedForwardFilter,
+	       signalVector **feedbackFilter);
+
+/**
+	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);
 
 #endif /* SIGPROCLIB_H */

Transceiver52M/signalVector.cpp

@@ -45,25 +45,11 @@ 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,12 +30,8 @@ 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/CMakeLists.txt

@@ -1,24 +0,0 @@
-include_directories(../common)
-
-set(libarch_files
-	../common/convert_base.c
-	../common/convolve_base.c
-	convert.c
-	convolve.c)
-
-# TODO move to cmakedef
-add_definitions(-DHAVE___BUILTIN_CPU_SUPPORTS)
-
-if(HAVE_SSE4_1)
-	add_definitions(-DHAVE_SSE4_1)
-	set(libarch_files ${libarch_files} convert_sse_4_1.c)
-endif(HAVE_SSE4_1)
-
-if(HAVE_SSE3)
-	add_definitions(-HAVE_SSE3)
-	set(libarch_files ${libarch_files} convert_sse_3.c convert_sse_3.c)
-endif(HAVE_SSE3)
-
-
-add_library(arch ${libarch_files})
-

Transceiver52M/x86/Makefile.am

@@ -1,32 +1,10 @@
 if !ARCH_ARM
-AM_CFLAGS = -Wall -std=gnu99 -I${srcdir}/../common
+AM_CFLAGS = -Wall -std=gnu99 -march=native -I../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,64 +20,181 @@
 #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
 
-/* 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___BUILTIN_CPU_SUPPORTS
-#ifdef HAVE_SSE4_1
-	if (__builtin_cpu_supports("sse4.1")) {
-		c.convert_si16_ps_16n = &_sse_convert_si16_ps_16n;
-		c.convert_si16_ps = &_sse_convert_si16_ps;
-	}
-#endif
-
 #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;
+#include <xmmintrin.h>
+#include <emmintrin.h>
+
+#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);
 	}
-#endif
-#endif
 }
 
-void convert_float_short(short *out, const float *in, float scale, int len)
+/* 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 (!(len % 16))
-		c.convert_scale_ps_si16_16n(out, in, scale, len);
+		_sse_convert_scale_ps_si16_16n(out, in, scale, len);
 	else if (!(len % 8))
-		c.convert_scale_ps_si16_8n(out, in, scale, len);
+		_sse_convert_scale_ps_si16_8n(out, in, scale, len);
 	else
-		c.convert_scale_ps_si16(out, in, scale, len);
+		_sse_convert_scale_ps_si16(out, in, scale, len);
+#else
+	convert_scale_ps_si16(out, in, scale, len);
+#endif
 }
 
-void convert_short_float(float *out, const short *in, int len)
+void convert_short_float(float *out, short *in, int len)
 {
+#ifdef HAVE_SSE4_1
 	if (!(len % 16))
-		c.convert_si16_ps_16n(out, in, len);
+		_sse_convert_si16_ps_16n(out, in, len);
 	else
-		c.convert_si16_ps(out, in, len);
+		_sse_convert_si16_ps(out, in, len);
+#else
+	convert_si16_ps(out, in, len);
+#endif
 }

Transceiver52M/x86/convert_sse_3.c

@@ -1,107 +0,0 @@
-/*
- * 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

@@ -1,34 +0,0 @@
-/*
- * 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

@@ -1,77 +0,0 @@
-/*
- * 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

@@ -1,28 +0,0 @@
-/*
- * 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,46 +21,20 @@
 #include <string.h>
 #include <stdio.h>
 #include "convolve.h"
-#include "convolve_sse_3.h"
 
 #ifdef HAVE_CONFIG_H
 #include "config.h"
 #endif
 
-/* Architecture dependant function pointers */
-struct convolve_cpu_context {
-	void (*conv_cmplx_4n) (const float *, int, const float *, int, float *,
-			       int, int, int, int, int);
-	void (*conv_cmplx_8n) (const float *, int, const float *, int, float *,
-			       int, int, int, int, int);
-	void (*conv_cmplx) (const float *, int, const float *, int, float *,
-			    int, int, int, int, int);
-	void (*conv_real4) (const float *, int, const float *, int, float *,
-			    int, int, int, int, int);
-	void (*conv_real8) (const float *, int, const float *, int, float *,
-			    int, int, int, int, int);
-	void (*conv_real12) (const float *, int, const float *, int, float *,
-			     int, int, int, int, int);
-	void (*conv_real16) (const float *, int, const float *, int, float *,
-			     int, int, int, int, int);
-	void (*conv_real20) (const float *, int, const float *, int, float *,
-			     int, int, int, int, int);
-	void (*conv_real4n) (const float *, int, const float *, int, float *,
-			     int, int, int, int, int);
-	void (*conv_real) (const float *, int, const float *, int, float *, int,
-			   int, int, int, int);
-};
-static struct convolve_cpu_context c;
-
 /* Forward declarations from base implementation */
-int _base_convolve_real(const float *x, int x_len,
-			const float *h, int h_len,
+int _base_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 _base_convolve_complex(const float *x, int x_len,
-			   const float *h, int h_len,
+int _base_convolve_complex(float *x, int x_len,
+			   float *h, int h_len,
 			   float *y, int y_len,
 			   int start, int len,
 			   int step, int offset);
@@ -68,105 +42,560 @@ int _base_convolve_complex(const float *x, int x_len,
 int bounds_check(int x_len, int h_len, int y_len,
 		 int start, int len, int step);
 
-/* API: Initalize convolve module */
-void convolve_init(void)
-{
-	c.conv_cmplx_4n = (void *)_base_convolve_complex;
-	c.conv_cmplx_8n = (void *)_base_convolve_complex;
-	c.conv_cmplx = (void *)_base_convolve_complex;
-	c.conv_real4 = (void *)_base_convolve_real;
-	c.conv_real8 = (void *)_base_convolve_real;
-	c.conv_real12 = (void *)_base_convolve_real;
-	c.conv_real16 = (void *)_base_convolve_real;
-	c.conv_real20 = (void *)_base_convolve_real;
-	c.conv_real4n = (void *)_base_convolve_real;
-	c.conv_real = (void *)_base_convolve_real;
+#ifdef HAVE_SSE3
+#include <xmmintrin.h>
+#include <pmmintrin.h>
 
-#if defined(HAVE_SSE3) && defined(HAVE___BUILTIN_CPU_SUPPORTS)
-	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;
+/* 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);
 	}
-#endif
 }
 
-/* API: Aligned complex-real */
-int convolve_real(const float *x, int x_len,
-		  const float *h, int h_len,
-		  float *y, int y_len, int start, int len, int step, int offset)
+/* 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)
+{
+	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:
-			c.conv_real4(x, x_len, h, h_len, y, y_len, start, len,
-				     step, offset);
+			conv_func = sse_conv_real4;
 			break;
 		case 8:
-			c.conv_real8(x, x_len, h, h_len, y, y_len, start, len,
-				     step, offset);
+			conv_func = sse_conv_real8;
 			break;
 		case 12:
-			c.conv_real12(x, x_len, h, h_len, y, y_len, start, len,
-				      step, offset);
+			conv_func = sse_conv_real12;
 			break;
 		case 16:
-			c.conv_real16(x, x_len, h, h_len, y, y_len, start, len,
-				      step, offset);
+			conv_func = sse_conv_real16;
 			break;
 		case 20:
-			c.conv_real20(x, x_len, h, h_len, y, y_len, start, len,
-				      step, offset);
+			conv_func = sse_conv_real20;
 			break;
 		default:
 			if (!(h_len % 4))
-				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);
+				conv_func_n = sse_conv_real4n;
 		}
-	} 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);
+	}
 
 	return len;
 }
 
 /* API: Aligned complex-complex */
-int convolve_complex(const float *x, int x_len,
-		     const float *h, int h_len,
+int convolve_complex(float *x, int x_len,
+		     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))
-			c.conv_cmplx_8n(x, x_len, h, h_len, y, y_len, start,
-					len, step, offset);
+			conv_func = sse_conv_cmplx_8n;
 		else if (!(h_len % 4))
-			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);
+			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);
+	}
 
 	return len;
 }

Transceiver52M/x86/convolve_sse_3.c

@@ -1,542 +0,0 @@
-/*
- * 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

@@ -1,68 +0,0 @@
-/*
- * 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);

cmake/FindFFTW.cmake

@@ -1,96 +0,0 @@
-# - Find the FFTW library
-#
-# Usage:
-#   find_package(FFTW [REQUIRED] [QUIET] )
-#     
-# It sets the following variables:
-#   FFTW_FOUND               ... true if fftw is found on the system
-#   FFTW_LIBRARIES           ... full path to fftw library
-#   FFTW_INCLUDES            ... fftw include directory
-#
-# The following variables will be checked by the function
-#   FFTW_USE_STATIC_LIBS    ... if true, only static libraries are found
-#   FFTW_ROOT               ... if set, the libraries are exclusively searched
-#                               under this path
-#   FFTW_LIBRARY            ... fftw library to use
-#   FFTW_INCLUDE_DIR        ... fftw include directory
-#
-#If environment variable FFTWDIR is specified, it has same effect as FFTW_ROOT
-if( NOT FFTW_ROOT AND ENV{FFTWDIR} )
-  set( FFTW_ROOT $ENV{FFTWDIR} )
-endif()
-# Check if we can use PkgConfig
-find_package(PkgConfig)
-#Determine from PKG
-if( PKG_CONFIG_FOUND AND NOT FFTW_ROOT )
-  pkg_check_modules( PKG_FFTW QUIET "fftw3" )
-endif()
-#Check whether to search static or dynamic libs
-set( CMAKE_FIND_LIBRARY_SUFFIXES_SAV ${CMAKE_FIND_LIBRARY_SUFFIXES} )
-if( ${FFTW_USE_STATIC_LIBS} )
-  set( CMAKE_FIND_LIBRARY_SUFFIXES ${CMAKE_STATIC_LIBRARY_SUFFIX} )
-else()
-  set( CMAKE_FIND_LIBRARY_SUFFIXES ${CMAKE_SHARED_LIBRARY_SUFFIX} )
-endif()
-if( FFTW_ROOT )
-  #find libs
-  find_library(
-    FFTW_LIB
-    NAMES "fftw3"
-    PATHS ${FFTW_ROOT}
-    PATH_SUFFIXES "lib" "lib64"
-    NO_DEFAULT_PATH
-  )
-  find_library(
-    FFTWF_LIB
-    NAMES "fftw3f"
-    PATHS ${FFTW_ROOT}
-    PATH_SUFFIXES "lib" "lib64"
-    NO_DEFAULT_PATH
-  )
-  find_library(
-    FFTWL_LIB
-    NAMES "fftw3l"
-    PATHS ${FFTW_ROOT}
-    PATH_SUFFIXES "lib" "lib64"
-    NO_DEFAULT_PATH
-  )
-  #find includes
-  find_path(
-    FFTW_INCLUDES
-    NAMES "fftw3.h"
-    PATHS ${FFTW_ROOT}
-    PATH_SUFFIXES "include"
-    NO_DEFAULT_PATH
-  )
-else()
-  find_library(
-    FFTW_LIB
-    NAMES "fftw3"
-    PATHS ${PKG_FFTW_LIBRARY_DIRS} ${LIB_INSTALL_DIR}
-  )
-  find_library(
-    FFTWF_LIB
-    NAMES "fftw3f"
-    PATHS ${PKG_FFTW_LIBRARY_DIRS} ${LIB_INSTALL_DIR}
-  )
-  find_library(
-    FFTWL_LIB
-    NAMES "fftw3l"
-    PATHS ${PKG_FFTW_LIBRARY_DIRS} ${LIB_INSTALL_DIR}
-  )
-  find_path(
-    FFTW_INCLUDES
-    NAMES "fftw3.h"
-    PATHS ${PKG_FFTW_INCLUDE_DIRS} ${INCLUDE_INSTALL_DIR}
-  )
-endif( FFTW_ROOT )
-set(FFTW_LIBRARIES ${FFTW_LIB} ${FFTWF_LIB})
-if(FFTWL_LIB)
-  set(FFTW_LIBRARIES ${FFTW_LIBRARIES} ${FFTWL_LIB})
-endif()
-set( CMAKE_FIND_LIBRARY_SUFFIXES ${CMAKE_FIND_LIBRARY_SUFFIXES_SAV} )
-include(FindPackageHandleStandardArgs)
-find_package_handle_standard_args(FFTW DEFAULT_MSG
-                                  FFTW_INCLUDES FFTW_LIBRARIES)
-mark_as_advanced(FFTW_INCLUDES FFTW_LIBRARIES FFTW_LIB FFTWF_LIB FFTWL_LIB)

cmake/FindXTRX.cmake

@@ -1,69 +0,0 @@
-# - Find the XTRX library
-#
-# Usage:
-#   find_package(XTRX [REQUIRED] [QUIET] )
-#     
-# It sets the following variables:
-#   XTRX_FOUND               ... true if XTRX is found on the system
-#   XTRX_LIBRARIES           ... full path to XTRX library
-#   XTRX_INCLUDES            ... XTRX include directory
-#
-# The following variables will be checked by the function
-#   XTRX_USE_STATIC_LIBS    ... if true, only static libraries are found
-#   XTRX_ROOT               ... if set, the libraries are exclusively searched
-#                               under this path
-#   XTRX_LIBRARY            ... XTRX library to use
-#   XTRX_INCLUDE_DIR        ... XTRX include directory
-#
-#If environment variable XTRXDIR is specified, it has same effect as XTRX_ROOT
-if( NOT XTRX_ROOT AND ENV{XTRXDIR} )
-  set( XTRX_ROOT $ENV{XTRXDIR} )
-endif()
-# Check if we can use PkgConfig
-find_package(PkgConfig)
-#Determine from PKG
-if( PKG_CONFIG_FOUND AND NOT XTRX_ROOT )
-  pkg_check_modules( PKG_XTRX QUIET "libxtrx" )
-endif()
-#Check whether to search static or dynamic libs
-set( CMAKE_FIND_LIBRARY_SUFFIXES_SAV ${CMAKE_FIND_LIBRARY_SUFFIXES} )
-if( ${XTRX_USE_STATIC_LIBS} )
-  set( CMAKE_FIND_LIBRARY_SUFFIXES ${CMAKE_STATIC_LIBRARY_SUFFIX} )
-else()
-  set( CMAKE_FIND_LIBRARY_SUFFIXES ${CMAKE_SHARED_LIBRARY_SUFFIX} )
-endif()
-if( XTRX_ROOT )
-  #find libs
-  find_library(
-    XTRX_LIB
-    NAMES "xtrx"
-    PATHS ${XTRX_ROOT}
-    PATH_SUFFIXES "lib" "lib64"
-    NO_DEFAULT_PATH
-  )
-  #find includes
-  find_path(
-    XTRX_INCLUDES
-    NAMES "xtrx_api.h"
-    PATHS ${XTRX_ROOT}
-    PATH_SUFFIXES "include"
-    NO_DEFAULT_PATH
-  )
-else()
-  find_library(
-    XTRX_LIB
-    NAMES "xtrx"
-    PATHS ${PKG_XTRX_LIBRARY_DIRS} ${LIB_INSTALL_DIR}
-  )
-  find_path(
-    XTRX_INCLUDES
-    NAMES "xtrx_api.h"
-    PATHS ${PKG_XTRX_INCLUDE_DIRS} ${INCLUDE_INSTALL_DIR}
-  )
-endif( XTRX_ROOT )
-set(XTRX_LIBRARIES ${XTRX_LIB})
-set( CMAKE_FIND_LIBRARY_SUFFIXES ${CMAKE_FIND_LIBRARY_SUFFIXES_SAV} )
-include(FindPackageHandleStandardArgs)
-find_package_handle_standard_args(XTRX DEFAULT_MSG
-                                  XTRX_INCLUDES XTRX_LIBRARIES)
-mark_as_advanced(XTRX_INCLUDES XTRX_LIBRARIES XTRX_LIB XTRXF_LIB XTRXL_LIB)

config/ax_cxx_compile_stdcxx.m4

@@ -1,982 +0,0 @@
-# ===========================================================================
-#  https://www.gnu.org/software/autoconf-archive/ax_cxx_compile_stdcxx.html
-# ===========================================================================
-#
-# SYNOPSIS
-#
-#   AX_CXX_COMPILE_STDCXX(VERSION, [ext|noext], [mandatory|optional])
-#
-# DESCRIPTION
-#
-#   Check for baseline language coverage in the compiler for the specified
-#   version of the C++ standard.  If necessary, add switches to CXX and
-#   CXXCPP to enable support.  VERSION may be '11' (for the C++11 standard)
-#   or '14' (for the C++14 standard).
-#
-#   The second argument, if specified, indicates whether you insist on an
-#   extended mode (e.g. -std=gnu++11) or a strict conformance mode (e.g.
-#   -std=c++11).  If neither is specified, you get whatever works, with
-#   preference for an extended mode.
-#
-#   The third argument, if specified 'mandatory' or if left unspecified,
-#   indicates that baseline support for the specified C++ standard is
-#   required and that the macro should error out if no mode with that
-#   support is found.  If specified 'optional', then configuration proceeds
-#   regardless, after defining HAVE_CXX${VERSION} if and only if a
-#   supporting mode is found.
-#
-# LICENSE
-#
-#   Copyright (c) 2008 Benjamin Kosnik <bkoz@redhat.com>
-#   Copyright (c) 2012 Zack Weinberg <zackw@panix.com>
-#   Copyright (c) 2013 Roy Stogner <roystgnr@ices.utexas.edu>
-#   Copyright (c) 2014, 2015 Google Inc.; contributed by Alexey Sokolov <sokolov@google.com>
-#   Copyright (c) 2015 Paul Norman <penorman@mac.com>
-#   Copyright (c) 2015 Moritz Klammler <moritz@klammler.eu>
-#   Copyright (c) 2016 Krzesimir Nowak <qdlacz@gmail.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 7
-
-dnl  This macro is based on the code from the AX_CXX_COMPILE_STDCXX_11 macro
-dnl  (serial version number 13).
-
-AX_REQUIRE_DEFINED([AC_MSG_WARN])
-AC_DEFUN([AX_CXX_COMPILE_STDCXX], [dnl
-  m4_if([$1], [11], [ax_cxx_compile_alternatives="11 0x"],
-        [$1], [14], [ax_cxx_compile_alternatives="14 1y"],
-        [$1], [17], [ax_cxx_compile_alternatives="17 1z"],
-        [m4_fatal([invalid first argument `$1' to AX_CXX_COMPILE_STDCXX])])dnl
-  m4_if([$2], [], [],
-        [$2], [ext], [],
-        [$2], [noext], [],
-        [m4_fatal([invalid second argument `$2' to AX_CXX_COMPILE_STDCXX])])dnl
-  m4_if([$3], [], [ax_cxx_compile_cxx$1_required=true],
-        [$3], [mandatory], [ax_cxx_compile_cxx$1_required=true],
-        [$3], [optional], [ax_cxx_compile_cxx$1_required=false],
-        [m4_fatal([invalid third argument `$3' to AX_CXX_COMPILE_STDCXX])])
-  AC_LANG_PUSH([C++])dnl
-  ac_success=no
-  AC_CACHE_CHECK(whether $CXX supports C++$1 features by default,
-  ax_cv_cxx_compile_cxx$1,
-  [AC_COMPILE_IFELSE([AC_LANG_SOURCE([_AX_CXX_COMPILE_STDCXX_testbody_$1])],
-    [ax_cv_cxx_compile_cxx$1=yes],
-    [ax_cv_cxx_compile_cxx$1=no])])
-  if test x$ax_cv_cxx_compile_cxx$1 = xyes; then
-    ac_success=yes
-  fi
-
-  m4_if([$2], [noext], [], [dnl
-  if test x$ac_success = xno; then
-    for alternative in ${ax_cxx_compile_alternatives}; do
-      switch="-std=gnu++${alternative}"
-      cachevar=AS_TR_SH([ax_cv_cxx_compile_cxx$1_$switch])
-      AC_CACHE_CHECK(whether $CXX supports C++$1 features with $switch,
-                     $cachevar,
-        [ac_save_CXX="$CXX"
-         CXX="$CXX $switch"
-         AC_COMPILE_IFELSE([AC_LANG_SOURCE([_AX_CXX_COMPILE_STDCXX_testbody_$1])],
-          [eval $cachevar=yes],
-          [eval $cachevar=no])
-         CXX="$ac_save_CXX"])
-      if eval test x\$$cachevar = xyes; then
-        CXX="$CXX $switch"
-        if test -n "$CXXCPP" ; then
-          CXXCPP="$CXXCPP $switch"
-        fi
-        ac_success=yes
-        break
-      fi
-    done
-  fi])
-
-  m4_if([$2], [ext], [], [dnl
-  if test x$ac_success = xno; then
-    dnl HP's aCC needs +std=c++11 according to:
-    dnl http://h21007.www2.hp.com/portal/download/files/unprot/aCxx/PDF_Release_Notes/769149-001.pdf
-    dnl Cray's crayCC needs "-h std=c++11"
-    for alternative in ${ax_cxx_compile_alternatives}; do
-      for switch in -std=c++${alternative} +std=c++${alternative} "-h std=c++${alternative}"; do
-        cachevar=AS_TR_SH([ax_cv_cxx_compile_cxx$1_$switch])
-        AC_CACHE_CHECK(whether $CXX supports C++$1 features with $switch,
-                       $cachevar,
-          [ac_save_CXX="$CXX"
-           CXX="$CXX $switch"
-           AC_COMPILE_IFELSE([AC_LANG_SOURCE([_AX_CXX_COMPILE_STDCXX_testbody_$1])],
-            [eval $cachevar=yes],
-            [eval $cachevar=no])
-           CXX="$ac_save_CXX"])
-        if eval test x\$$cachevar = xyes; then
-          CXX="$CXX $switch"
-          if test -n "$CXXCPP" ; then
-            CXXCPP="$CXXCPP $switch"
-          fi
-          ac_success=yes
-          break
-        fi
-      done
-      if test x$ac_success = xyes; then
-        break
-      fi
-    done
-  fi])
-  AC_LANG_POP([C++])
-  if test x$ax_cxx_compile_cxx$1_required = xtrue; then
-    if test x$ac_success = xno; then
-      AC_MSG_ERROR([*** A compiler with support for C++$1 language features is required.])
-    fi
-  fi
-  if test x$ac_success = xno; then
-    HAVE_CXX$1=0
-    AC_MSG_NOTICE([No compiler with C++$1 support was found])
-  else
-    HAVE_CXX$1=1
-    AC_DEFINE(HAVE_CXX$1,1,
-              [define if the compiler supports basic C++$1 syntax])
-  fi
-  AC_SUBST(HAVE_CXX$1)
-  m4_if([$1], [17], [AC_MSG_WARN([C++17 is not yet standardized, so the checks may change in incompatible ways anytime])])
-])
-
-
-dnl  Test body for checking C++11 support
-
-m4_define([_AX_CXX_COMPILE_STDCXX_testbody_11],
-  _AX_CXX_COMPILE_STDCXX_testbody_new_in_11
-)
-
-
-dnl  Test body for checking C++14 support
-
-m4_define([_AX_CXX_COMPILE_STDCXX_testbody_14],
-  _AX_CXX_COMPILE_STDCXX_testbody_new_in_11
-  _AX_CXX_COMPILE_STDCXX_testbody_new_in_14
-)
-
-m4_define([_AX_CXX_COMPILE_STDCXX_testbody_17],
-  _AX_CXX_COMPILE_STDCXX_testbody_new_in_11
-  _AX_CXX_COMPILE_STDCXX_testbody_new_in_14
-  _AX_CXX_COMPILE_STDCXX_testbody_new_in_17
-)
-
-dnl  Tests for new features in C++11
-
-m4_define([_AX_CXX_COMPILE_STDCXX_testbody_new_in_11], [[
-
-// If the compiler admits that it is not ready for C++11, why torture it?
-// Hopefully, this will speed up the test.
-
-#ifndef __cplusplus
-
-#error "This is not a C++ compiler"
-
-#elif __cplusplus < 201103L
-
-#error "This is not a C++11 compiler"
-
-#else
-
-namespace cxx11
-{
-
-  namespace test_static_assert
-  {
-
-    template <typename T>
-    struct check
-    {
-      static_assert(sizeof(int) <= sizeof(T), "not big enough");
-    };
-
-  }
-
-  namespace test_final_override
-  {
-
-    struct Base
-    {
-      virtual void f() {}
-    };
-
-    struct Derived : public Base
-    {
-      virtual void f() override {}
-    };
-
-  }
-
-  namespace test_double_right_angle_brackets
-  {
-
-    template < typename T >
-    struct check {};
-
-    typedef check<void> single_type;
-    typedef check<check<void>> double_type;
-    typedef check<check<check<void>>> triple_type;
-    typedef check<check<check<check<void>>>> quadruple_type;
-
-  }
-
-  namespace test_decltype
-  {
-
-    int
-    f()
-    {
-      int a = 1;
-      decltype(a) b = 2;
-      return a + b;
-    }
-
-  }
-
-  namespace test_type_deduction
-  {
-
-    template < typename T1, typename T2 >
-    struct is_same
-    {
-      static const bool value = false;
-    };
-
-    template < typename T >
-    struct is_same<T, T>
-    {
-      static const bool value = true;
-    };
-
-    template < typename T1, typename T2 >
-    auto
-    add(T1 a1, T2 a2) -> decltype(a1 + a2)
-    {
-      return a1 + a2;
-    }
-
-    int
-    test(const int c, volatile int v)
-    {
-      static_assert(is_same<int, decltype(0)>::value == true, "");
-      static_assert(is_same<int, decltype(c)>::value == false, "");
-      static_assert(is_same<int, decltype(v)>::value == false, "");
-      auto ac = c;
-      auto av = v;
-      auto sumi = ac + av + 'x';
-      auto sumf = ac + av + 1.0;
-      static_assert(is_same<int, decltype(ac)>::value == true, "");
-      static_assert(is_same<int, decltype(av)>::value == true, "");
-      static_assert(is_same<int, decltype(sumi)>::value == true, "");
-      static_assert(is_same<int, decltype(sumf)>::value == false, "");
-      static_assert(is_same<int, decltype(add(c, v))>::value == true, "");
-      return (sumf > 0.0) ? sumi : add(c, v);
-    }
-
-  }
-
-  namespace test_noexcept
-  {
-
-    int f() { return 0; }
-    int g() noexcept { return 0; }
-
-    static_assert(noexcept(f()) == false, "");
-    static_assert(noexcept(g()) == true, "");
-
-  }
-
-  namespace test_constexpr
-  {
-
-    template < typename CharT >
-    unsigned long constexpr
-    strlen_c_r(const CharT *const s, const unsigned long acc) noexcept
-    {
-      return *s ? strlen_c_r(s + 1, acc + 1) : acc;
-    }
-
-    template < typename CharT >
-    unsigned long constexpr
-    strlen_c(const CharT *const s) noexcept
-    {
-      return strlen_c_r(s, 0UL);
-    }
-
-    static_assert(strlen_c("") == 0UL, "");
-    static_assert(strlen_c("1") == 1UL, "");
-    static_assert(strlen_c("example") == 7UL, "");
-    static_assert(strlen_c("another\0example") == 7UL, "");
-
-  }
-
-  namespace test_rvalue_references
-  {
-
-    template < int N >
-    struct answer
-    {
-      static constexpr int value = N;
-    };
-
-    answer<1> f(int&)       { return answer<1>(); }
-    answer<2> f(const int&) { return answer<2>(); }
-    answer<3> f(int&&)      { return answer<3>(); }
-
-    void
-    test()
-    {
-      int i = 0;
-      const int c = 0;
-      static_assert(decltype(f(i))::value == 1, "");
-      static_assert(decltype(f(c))::value == 2, "");
-      static_assert(decltype(f(0))::value == 3, "");
-    }
-
-  }
-
-  namespace test_uniform_initialization
-  {
-
-    struct test
-    {
-      static const int zero {};
-      static const int one {1};
-    };
-
-    static_assert(test::zero == 0, "");
-    static_assert(test::one == 1, "");
-
-  }
-
-  namespace test_lambdas
-  {
-
-    void
-    test1()
-    {
-      auto lambda1 = [](){};
-      auto lambda2 = lambda1;
-      lambda1();
-      lambda2();
-    }
-
-    int
-    test2()
-    {
-      auto a = [](int i, int j){ return i + j; }(1, 2);
-      auto b = []() -> int { return '0'; }();
-      auto c = [=](){ return a + b; }();
-      auto d = [&](){ return c; }();
-      auto e = [a, &b](int x) mutable {
-        const auto identity = [](int y){ return y; };
-        for (auto i = 0; i < a; ++i)
-          a += b--;
-        return x + identity(a + b);
-      }(0);
-      return a + b + c + d + e;
-    }
-
-    int
-    test3()
-    {
-      const auto nullary = [](){ return 0; };
-      const auto unary = [](int x){ return x; };
-      using nullary_t = decltype(nullary);
-      using unary_t = decltype(unary);
-      const auto higher1st = [](nullary_t f){ return f(); };
-      const auto higher2nd = [unary](nullary_t f1){
-        return [unary, f1](unary_t f2){ return f2(unary(f1())); };
-      };
-      return higher1st(nullary) + higher2nd(nullary)(unary);
-    }
-
-  }
-
-  namespace test_variadic_templates
-  {
-
-    template <int...>
-    struct sum;
-
-    template <int N0, int... N1toN>
-    struct sum<N0, N1toN...>
-    {
-      static constexpr auto value = N0 + sum<N1toN...>::value;
-    };
-
-    template <>
-    struct sum<>
-    {
-      static constexpr auto value = 0;
-    };
-
-    static_assert(sum<>::value == 0, "");
-    static_assert(sum<1>::value == 1, "");
-    static_assert(sum<23>::value == 23, "");
-    static_assert(sum<1, 2>::value == 3, "");
-    static_assert(sum<5, 5, 11>::value == 21, "");
-    static_assert(sum<2, 3, 5, 7, 11, 13>::value == 41, "");
-
-  }
-
-  // http://stackoverflow.com/questions/13728184/template-aliases-and-sfinae
-  // Clang 3.1 fails with headers of libstd++ 4.8.3 when using std::function
-  // because of this.
-  namespace test_template_alias_sfinae
-  {
-
-    struct foo {};
-
-    template<typename T>
-    using member = typename T::member_type;
-
-    template<typename T>
-    void func(...) {}
-
-    template<typename T>
-    void func(member<T>*) {}
-
-    void test();
-
-    void test() { func<foo>(0); }
-
-  }
-
-}  // namespace cxx11
-
-#endif  // __cplusplus >= 201103L
-
-]])
-
-
-dnl  Tests for new features in C++14
-
-m4_define([_AX_CXX_COMPILE_STDCXX_testbody_new_in_14], [[
-
-// If the compiler admits that it is not ready for C++14, why torture it?
-// Hopefully, this will speed up the test.
-
-#ifndef __cplusplus
-
-#error "This is not a C++ compiler"
-
-#elif __cplusplus < 201402L
-
-#error "This is not a C++14 compiler"
-
-#else
-
-namespace cxx14
-{
-
-  namespace test_polymorphic_lambdas
-  {
-
-    int
-    test()
-    {
-      const auto lambda = [](auto&&... args){
-        const auto istiny = [](auto x){
-          return (sizeof(x) == 1UL) ? 1 : 0;
-        };
-        const int aretiny[] = { istiny(args)... };
-        return aretiny[0];
-      };
-      return lambda(1, 1L, 1.0f, '1');
-    }
-
-  }
-
-  namespace test_binary_literals
-  {
-
-    constexpr auto ivii = 0b0000000000101010;
-    static_assert(ivii == 42, "wrong value");
-
-  }
-
-  namespace test_generalized_constexpr
-  {
-
-    template < typename CharT >
-    constexpr unsigned long
-    strlen_c(const CharT *const s) noexcept
-    {
-      auto length = 0UL;
-      for (auto p = s; *p; ++p)
-        ++length;
-      return length;
-    }
-
-    static_assert(strlen_c("") == 0UL, "");
-    static_assert(strlen_c("x") == 1UL, "");
-    static_assert(strlen_c("test") == 4UL, "");
-    static_assert(strlen_c("another\0test") == 7UL, "");
-
-  }
-
-  namespace test_lambda_init_capture
-  {
-
-    int
-    test()
-    {
-      auto x = 0;
-      const auto lambda1 = [a = x](int b){ return a + b; };
-      const auto lambda2 = [a = lambda1(x)](){ return a; };
-      return lambda2();
-    }
-
-  }
-
-  namespace test_digit_separators
-  {
-
-    constexpr auto ten_million = 100'000'000;
-    static_assert(ten_million == 100000000, "");
-
-  }
-
-  namespace test_return_type_deduction
-  {
-
-    auto f(int& x) { return x; }
-    decltype(auto) g(int& x) { return x; }
-
-    template < typename T1, typename T2 >
-    struct is_same
-    {
-      static constexpr auto value = false;
-    };
-
-    template < typename T >
-    struct is_same<T, T>
-    {
-      static constexpr auto value = true;
-    };
-
-    int
-    test()
-    {
-      auto x = 0;
-      static_assert(is_same<int, decltype(f(x))>::value, "");
-      static_assert(is_same<int&, decltype(g(x))>::value, "");
-      return x;
-    }
-
-  }
-
-}  // namespace cxx14
-
-#endif  // __cplusplus >= 201402L
-
-]])
-
-
-dnl  Tests for new features in C++17
-
-m4_define([_AX_CXX_COMPILE_STDCXX_testbody_new_in_17], [[
-
-// If the compiler admits that it is not ready for C++17, why torture it?
-// Hopefully, this will speed up the test.
-
-#ifndef __cplusplus
-
-#error "This is not a C++ compiler"
-
-#elif __cplusplus <= 201402L
-
-#error "This is not a C++17 compiler"
-
-#else
-
-#if defined(__clang__)
-  #define REALLY_CLANG
-#else
-  #if defined(__GNUC__)
-    #define REALLY_GCC
-  #endif
-#endif
-
-#include <initializer_list>
-#include <utility>
-#include <type_traits>
-
-namespace cxx17
-{
-
-#if !defined(REALLY_CLANG)
-  namespace test_constexpr_lambdas
-  {
-
-    // TODO: test it with clang++ from git
-
-    constexpr int foo = [](){return 42;}();
-
-  }
-#endif // !defined(REALLY_CLANG)
-
-  namespace test::nested_namespace::definitions
-  {
-
-  }
-
-  namespace test_fold_expression
-  {
-
-    template<typename... Args>
-    int multiply(Args... args)
-    {
-      return (args * ... * 1);
-    }
-
-    template<typename... Args>
-    bool all(Args... args)
-    {
-      return (args && ...);
-    }
-
-  }
-
-  namespace test_extended_static_assert
-  {
-
-    static_assert (true);
-
-  }
-
-  namespace test_auto_brace_init_list
-  {
-
-    auto foo = {5};
-    auto bar {5};
-
-    static_assert(std::is_same<std::initializer_list<int>, decltype(foo)>::value);
-    static_assert(std::is_same<int, decltype(bar)>::value);
-  }
-
-  namespace test_typename_in_template_template_parameter
-  {
-
-    template<template<typename> typename X> struct D;
-
-  }
-
-  namespace test_fallthrough_nodiscard_maybe_unused_attributes
-  {
-
-    int f1()
-    {
-      return 42;
-    }
-
-    [[nodiscard]] int f2()
-    {
-      [[maybe_unused]] auto unused = f1();
-
-      switch (f1())
-      {
-      case 17:
-        f1();
-        [[fallthrough]];
-      case 42:
-        f1();
-      }
-      return f1();
-    }
-
-  }
-
-  namespace test_extended_aggregate_initialization
-  {
-
-    struct base1
-    {
-      int b1, b2 = 42;
-    };
-
-    struct base2
-    {
-      base2() {
-        b3 = 42;
-      }
-      int b3;
-    };
-
-    struct derived : base1, base2
-    {
-        int d;
-    };
-
-    derived d1 {{1, 2}, {}, 4};  // full initialization
-    derived d2 {{}, {}, 4};      // value-initialized bases
-
-  }
-
-  namespace test_general_range_based_for_loop
-  {
-
-    struct iter
-    {
-      int i;
-
-      int& operator* ()
-      {
-        return i;
-      }
-
-      const int& operator* () const
-      {
-        return i;
-      }
-
-      iter& operator++()
-      {
-        ++i;
-        return *this;
-      }
-    };
-
-    struct sentinel
-    {
-      int i;
-    };
-
-    bool operator== (const iter& i, const sentinel& s)
-    {
-      return i.i == s.i;
-    }
-
-    bool operator!= (const iter& i, const sentinel& s)
-    {
-      return !(i == s);
-    }
-
-    struct range
-    {
-      iter begin() const
-      {
-        return {0};
-      }
-
-      sentinel end() const
-      {
-        return {5};
-      }
-    };
-
-    void f()
-    {
-      range r {};
-
-      for (auto i : r)
-      {
-        [[maybe_unused]] auto v = i;
-      }
-    }
-
-  }
-
-  namespace test_lambda_capture_asterisk_this_by_value
-  {
-
-    struct t
-    {
-      int i;
-      int foo()
-      {
-        return [*this]()
-        {
-          return i;
-        }();
-      }
-    };
-
-  }
-
-  namespace test_enum_class_construction
-  {
-
-    enum class byte : unsigned char
-    {};
-
-    byte foo {42};
-
-  }
-
-  namespace test_constexpr_if
-  {
-
-    template <bool cond>
-    int f ()
-    {
-      if constexpr(cond)
-      {
-        return 13;
-      }
-      else
-      {
-        return 42;
-      }
-    }
-
-  }
-
-  namespace test_selection_statement_with_initializer
-  {
-
-    int f()
-    {
-      return 13;
-    }
-
-    int f2()
-    {
-      if (auto i = f(); i > 0)
-      {
-        return 3;
-      }
-
-      switch (auto i = f(); i + 4)
-      {
-      case 17:
-        return 2;
-
-      default:
-        return 1;
-      }
-    }
-
-  }
-
-#if !defined(REALLY_CLANG)
-  namespace test_template_argument_deduction_for_class_templates
-  {
-
-    // TODO: test it with clang++ from git
-
-    template <typename T1, typename T2>
-    struct pair
-    {
-      pair (T1 p1, T2 p2)
-        : m1 {p1},
-          m2 {p2}
-      {}
-
-      T1 m1;
-      T2 m2;
-    };
-
-    void f()
-    {
-      [[maybe_unused]] auto p = pair{13, 42u};
-    }
-
-  }
-#endif // !defined(REALLY_CLANG)
-
-  namespace test_non_type_auto_template_parameters
-  {
-
-    template <auto n>
-    struct B
-    {};
-
-    B<5> b1;
-    B<'a'> b2;
-
-  }
-
-#if !defined(REALLY_CLANG)
-  namespace test_structured_bindings
-  {
-
-    // TODO: test it with clang++ from git
-
-    int arr[2] = { 1, 2 };
-    std::pair<int, int> pr = { 1, 2 };
-
-    auto f1() -> int(&)[2]
-    {
-      return arr;
-    }
-
-    auto f2() -> std::pair<int, int>&
-    {
-      return pr;
-    }
-
-    struct S
-    {
-      int x1 : 2;
-      volatile double y1;
-    };
-
-    S f3()
-    {
-      return {};
-    }
-
-    auto [ x1, y1 ] = f1();
-    auto& [ xr1, yr1 ] = f1();
-    auto [ x2, y2 ] = f2();
-    auto& [ xr2, yr2 ] = f2();
-    const auto [ x3, y3 ] = f3();
-
-  }
-#endif // !defined(REALLY_CLANG)
-
-#if !defined(REALLY_CLANG)
-  namespace test_exception_spec_type_system
-  {
-
-    // TODO: test it with clang++ from git
-
-    struct Good {};
-    struct Bad {};
-
-    void g1() noexcept;
-    void g2();
-
-    template<typename T>
-    Bad
-    f(T*, T*);
-
-    template<typename T1, typename T2>
-    Good
-    f(T1*, T2*);
-
-    static_assert (std::is_same_v<Good, decltype(f(g1, g2))>);
-
-  }
-#endif // !defined(REALLY_CLANG)
-
-  namespace test_inline_variables
-  {
-
-    template<class T> void f(T)
-    {}
-
-    template<class T> inline T g(T)
-    {
-      return T{};
-    }
-
-    template<> inline void f<>(int)
-    {}
-
-    template<> int g<>(int)
-    {
-      return 5;
-    }
-
-  }
-
-}  // namespace cxx17
-
-#endif  // __cplusplus <= 201402L
-
-]])

config/ax_cxx_compile_stdcxx_11.m4

@@ -1,39 +0,0 @@
-# =============================================================================
-#  https://www.gnu.org/software/autoconf-archive/ax_cxx_compile_stdcxx_11.html
-# =============================================================================
-#
-# SYNOPSIS
-#
-#   AX_CXX_COMPILE_STDCXX_11([ext|noext], [mandatory|optional])
-#
-# DESCRIPTION
-#
-#   Check for baseline language coverage in the compiler for the C++11
-#   standard; if necessary, add switches to CXX and CXXCPP to enable
-#   support.
-#
-#   This macro is a convenience alias for calling the AX_CXX_COMPILE_STDCXX
-#   macro with the version set to C++11.  The two optional arguments are
-#   forwarded literally as the second and third argument respectively.
-#   Please see the documentation for the AX_CXX_COMPILE_STDCXX macro for
-#   more information.  If you want to use this macro, you also need to
-#   download the ax_cxx_compile_stdcxx.m4 file.
-#
-# LICENSE
-#
-#   Copyright (c) 2008 Benjamin Kosnik <bkoz@redhat.com>
-#   Copyright (c) 2012 Zack Weinberg <zackw@panix.com>
-#   Copyright (c) 2013 Roy Stogner <roystgnr@ices.utexas.edu>
-#   Copyright (c) 2014, 2015 Google Inc.; contributed by Alexey Sokolov <sokolov@google.com>
-#   Copyright (c) 2015 Paul Norman <penorman@mac.com>
-#   Copyright (c) 2015 Moritz Klammler <moritz@klammler.eu>
-#
-#   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 18
-
-AX_REQUIRE_DEFINED([AX_CXX_COMPILE_STDCXX])
-AC_DEFUN([AX_CXX_COMPILE_STDCXX_11], [AX_CXX_COMPILE_STDCXX([11], [$1], [$2])])

config/ax_ext.m4

@@ -0,0 +1,221 @@
+# ===========================================================================
+#          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_gcc_x86_avx_xgetbv.m4

@@ -0,0 +1,79 @@
+# ===========================================================================
+#   http://www.gnu.org/software/autoconf-archive/ax_gcc_x86_avx_xgetbv.html
+# ===========================================================================
+#
+# SYNOPSIS
+#
+#   AX_GCC_X86_AVX_XGETBV
+#
+# DESCRIPTION
+#
+#   On later x86 processors with AVX SIMD support, with gcc or a compiler
+#   that has a compatible syntax for inline assembly instructions, run a
+#   small program that executes the xgetbv instruction with input OP. This
+#   can be used to detect if the OS supports AVX instruction usage.
+#
+#   On output, the values of the eax and edx registers are stored as
+#   hexadecimal strings as "eax:edx" in the cache variable
+#   ax_cv_gcc_x86_avx_xgetbv.
+#
+#   If the xgetbv instruction fails (because you are running a
+#   cross-compiler, or because you are not using gcc, or because you are on
+#   a processor that doesn't have this instruction),
+#   ax_cv_gcc_x86_avx_xgetbv_OP is set to the string "unknown".
+#
+#   This macro mainly exists to be used in AX_EXT.
+#
+# LICENSE
+#
+#   Copyright (c) 2013 Michael Petch <mpetch@capp-sysware.com>
+#
+#   This program is free software: you can redistribute it and/or modify it
+#   under the terms of the GNU General Public License as published by the
+#   Free Software Foundation, either version 3 of the License, or (at your
+#   option) any later version.
+#
+#   This program is distributed in the hope that it will be useful, but
+#   WITHOUT ANY WARRANTY; without even the implied warranty of
+#   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General
+#   Public License for more details.
+#
+#   You should have received a copy of the GNU General Public License along
+#   with this program. If not, see <http://www.gnu.org/licenses/>.
+#
+#   As a special exception, the respective Autoconf Macro's copyright owner
+#   gives unlimited permission to copy, distribute and modify the configure
+#   scripts that are the output of Autoconf when processing the Macro. You
+#   need not follow the terms of the GNU General Public License when using
+#   or distributing such scripts, even though portions of the text of the
+#   Macro appear in them. The GNU General Public License (GPL) does govern
+#   all other use of the material that constitutes the Autoconf Macro.
+#
+#   This special exception to the GPL applies to versions of the Autoconf
+#   Macro released by the Autoconf Archive. When you make and distribute a
+#   modified version of the Autoconf Macro, you may extend this special
+#   exception to the GPL to apply to your modified version as well.
+
+#serial 1
+
+AC_DEFUN([AX_GCC_X86_AVX_XGETBV],
+[AC_REQUIRE([AC_PROG_CC])
+AC_LANG_PUSH([C])
+AC_CACHE_CHECK(for x86-AVX xgetbv $1 output, ax_cv_gcc_x86_avx_xgetbv_$1,
+ [AC_RUN_IFELSE([AC_LANG_PROGRAM([#include <stdio.h>], [
+     int op = $1, eax, edx;
+     FILE *f;
+      /* Opcodes for xgetbv */
+      __asm__(".byte 0x0f, 0x01, 0xd0"
+        : "=a" (eax), "=d" (edx)
+        : "c" (op));
+     f = fopen("conftest_xgetbv", "w"); if (!f) return 1;
+     fprintf(f, "%x:%x\n", eax, edx);
+     fclose(f);
+     return 0;
+])],
+     [ax_cv_gcc_x86_avx_xgetbv_$1=`cat conftest_xgetbv`; rm -f conftest_xgetbv],
+     [ax_cv_gcc_x86_avx_xgetbv_$1=unknown; rm -f conftest_xgetbv],
+     [ax_cv_gcc_x86_avx_xgetbv_$1=unknown])])
+AC_LANG_POP([C])
+])

config/ax_gcc_x86_cpuid.m4

@@ -0,0 +1,79 @@
+# ===========================================================================
+#     http://www.gnu.org/software/autoconf-archive/ax_gcc_x86_cpuid.html
+# ===========================================================================
+#
+# SYNOPSIS
+#
+#   AX_GCC_X86_CPUID(OP)
+#
+# DESCRIPTION
+#
+#   On Pentium and later x86 processors, with gcc or a compiler that has a
+#   compatible syntax for inline assembly instructions, run a small program
+#   that executes the cpuid instruction with input OP. This can be used to
+#   detect the CPU type.
+#
+#   On output, the values of the eax, ebx, ecx, and edx registers are stored
+#   as hexadecimal strings as "eax:ebx:ecx:edx" in the cache variable
+#   ax_cv_gcc_x86_cpuid_OP.
+#
+#   If the cpuid instruction fails (because you are running a
+#   cross-compiler, or because you are not using gcc, or because you are on
+#   a processor that doesn't have this instruction), ax_cv_gcc_x86_cpuid_OP
+#   is set to the string "unknown".
+#
+#   This macro mainly exists to be used in AX_GCC_ARCHFLAG.
+#
+# LICENSE
+#
+#   Copyright (c) 2008 Steven G. Johnson <stevenj@alum.mit.edu>
+#   Copyright (c) 2008 Matteo Frigo
+#
+#   This program is free software: you can redistribute it and/or modify it
+#   under the terms of the GNU General Public License as published by the
+#   Free Software Foundation, either version 3 of the License, or (at your
+#   option) any later version.
+#
+#   This program is distributed in the hope that it will be useful, but
+#   WITHOUT ANY WARRANTY; without even the implied warranty of
+#   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General
+#   Public License for more details.
+#
+#   You should have received a copy of the GNU General Public License along
+#   with this program. If not, see <http://www.gnu.org/licenses/>.
+#
+#   As a special exception, the respective Autoconf Macro's copyright owner
+#   gives unlimited permission to copy, distribute and modify the configure
+#   scripts that are the output of Autoconf when processing the Macro. You
+#   need not follow the terms of the GNU General Public License when using
+#   or distributing such scripts, even though portions of the text of the
+#   Macro appear in them. The GNU General Public License (GPL) does govern
+#   all other use of the material that constitutes the Autoconf Macro.
+#
+#   This special exception to the GPL applies to versions of the Autoconf
+#   Macro released by the Autoconf Archive. When you make and distribute a
+#   modified version of the Autoconf Macro, you may extend this special
+#   exception to the GPL to apply to your modified version as well.
+
+#serial 7
+
+AC_DEFUN([AX_GCC_X86_CPUID],
+[AC_REQUIRE([AC_PROG_CC])
+AC_LANG_PUSH([C])
+AC_CACHE_CHECK(for x86 cpuid $1 output, ax_cv_gcc_x86_cpuid_$1,
+ [AC_RUN_IFELSE([AC_LANG_PROGRAM([#include <stdio.h>], [
+     int op = $1, eax, ebx, ecx, edx;
+     FILE *f;
+      __asm__("cpuid"
+        : "=a" (eax), "=b" (ebx), "=c" (ecx), "=d" (edx)
+        : "a" (op));
+     f = fopen("conftest_cpuid", "w"); if (!f) return 1;
+     fprintf(f, "%x:%x:%x:%x\n", eax, ebx, ecx, edx);
+     fclose(f);
+     return 0;
+])],
+     [ax_cv_gcc_x86_cpuid_$1=`cat conftest_cpuid`; rm -f conftest_cpuid],
+     [ax_cv_gcc_x86_cpuid_$1=unknown; rm -f conftest_cpuid],
+     [ax_cv_gcc_x86_cpuid_$1=unknown])])
+AC_LANG_POP([C])
+])

config/ax_sse.m4

@@ -1,71 +0,0 @@
-# ===========================================================================
-#          http://www.gnu.org/software/autoconf-archive/ax_ext.html
-# ===========================================================================
-#
-# SYNOPSIS
-#
-#   AX_SSE
-#
-# DESCRIPTION
-#
-#   Find SIMD extensions supported by compiler. 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_SSE3 / HAVE_SSE4.1
-#
-# 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])
-
-  AM_CONDITIONAL(HAVE_SSE3, false)
-  AM_CONDITIONAL(HAVE_SSE4_1, false)
-
-  case $host_cpu in
-    i[[3456]]86*|x86_64*|amd64*)
-      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])
-      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])
-      fi
-  ;;
-  esac
-
-  AC_SUBST(SIMD_FLAGS)
-])

configure.ac

@@ -18,9 +18,7 @@ dnl You should have received a copy of the GNU General Public License
 dnl along with this program.  If not, see <http://www.gnu.org/licenses/>.
 dnl
 
-AC_INIT([osmo-trx],
-	m4_esyscmd([./git-version-gen .tarball-veresion]),
-	[openbsc@lists.osmocom.org])
+AC_INIT(openbts,P2.8TRUNK)
 AC_PREREQ(2.57)
 AC_CONFIG_SRCDIR([Transceiver52M/Makefile.am])
 AC_CONFIG_AUX_DIR([.])	
@@ -36,13 +34,8 @@ AM_INIT_AUTOMAKE([subdir-objects])
 dnl Linux kernel KBuild style compile messages
 m4_ifdef([AM_SILENT_RULES], [AM_SILENT_RULES([yes])])
 
-dnl include release helper
-RELMAKE='-include osmo-release.mk'
-AC_SUBST([RELMAKE])
-
 AM_PROG_AS
 AC_PROG_CXX
-AX_CXX_COMPILE_STDCXX_11
 AC_PROG_LN_S
 AC_PROG_MAKE_SET
 AC_PROG_INSTALL
@@ -104,15 +97,8 @@ AS_IF([test "x$with_usrp1" = "xyes"], [
 ])
 
 AS_IF([test "x$with_usrp1" != "xyes"],[
-    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)
+    PKG_CHECK_MODULES(UHD, uhd >= 003.004.000)
+    AC_DEFINE(USE_UHD, 1, Define to 1 if using UHD)
 ])
 
 AS_IF([test "x$with_singledb" = "xyes"], [
@@ -121,50 +107,14 @@ AS_IF([test "x$with_singledb" = "xyes"], [
 
 # Find and define supported SIMD extensions
 AS_IF([test "x$with_sse" != "xno"], [
-    AX_SSE
-], [
-    AM_CONDITIONAL(HAVE_SSE3, false)
-    AM_CONDITIONAL(HAVE_SSE4_1, false)
+    AX_EXT
 ])
 
-dnl Check if the compiler supports specified GCC's built-in function
-AC_DEFUN([CHECK_BUILTIN_SUPPORT], [
-  AC_CACHE_CHECK(
-    [whether ${CC} has $1 built-in],
-    [osmo_cv_cc_has_builtin], [
-      AC_LINK_IFELSE([
-        AC_LANG_PROGRAM([], [
-          __builtin_cpu_supports("sse");
-        ])
-      ],
-      [AS_VAR_SET([osmo_cv_cc_has_builtin], [yes])],
-      [AS_VAR_SET([osmo_cv_cc_has_builtin], [no])])
-    ]
-  )
-
-  AS_IF([test yes = AS_VAR_GET([osmo_cv_cc_has_builtin])], [
-    AC_DEFINE_UNQUOTED(AS_TR_CPP(HAVE_$1), 1,
-      [Define to 1 if compiler has the '$1' built-in function])
-  ], [
-    AC_MSG_WARN($2)
-  ])
-])
-
-dnl Check if the compiler supports runtime SIMD detection
-CHECK_BUILTIN_SUPPORT([__builtin_cpu_supports],
-  [Runtime SIMD detection will be disabled])
-
 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([\
@@ -174,6 +124,7 @@ AC_CONFIG_FILES([\
     Transceiver52M/Makefile \
     Transceiver52M/arm/Makefile \
     Transceiver52M/x86/Makefile \
+    sqlite3/Makefile \
 ])
 
 AC_OUTPUT

contrib/jenkins.sh

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

debian/changelog

@@ -1,178 +0,0 @@
-osmo-trx (0.2.0) unstable; urgency=medium
-
-  [ Alexander Chemeris ]
-  * EDGE: Add support for UmTRX.
-  * Common: Get rid of a compilation warning.
-  * Common: Make sure gLogEarly() log to the same facilities as the normal log.
-  * transceiver: Properly handle MAXDLY.
-  * transceiver: Add an option to generate random Access Bursts.
-  * osmo-trx: Output Rx SPS as a part of configuration output.
-  * transceiver: Do not pass transceiver state struct to function where it's not used.
-  * makefile: Fix build from an external path.
-  * radioDevice: GSMRATE macro must have parentheses around its definition.
-  * uhd: Fix comment.
-  * radioInterface: Initialize power scale with a meaningful default.
-  * transceiver: Log channel number in DEBUG output of demoded bursts.
-  * transceiver: Add an option to emulate a RACH delay in random filler mode.
-  * UHD: Initial LimeSDR support.
-  * CommonLibs: Remove unused files.
-  * sigProcLib: Typo sybols -> symbols
-  * radioBuffer: Remove extra ; at the end of inline function definitions.
-  * sigProcLib: Fix documentation, sync argument names in .cpp and .h files.
-  * sigProcLib: make energyDetect() simpler by returning actual energy.
-  * sigProcLib: Rename demodulateBurst() to demodGmskBurst() for clarity.
-  * sigProcLib: Slice SoftVector instead of signalVector for GMSK demod.
-  * Call vectorSlicer() right before packing bits for transmission to osmo-bts.
-  * CommonLibs: Print soft bits with less confidence to console when printing a soft vector.
-  * BitVector: Remove convolutional codec - we don't use it in osmo-trx.
-  * BitVector: Convert SoftVector from 0..1 to -1..+1 soft bits.
-  * signalVector: Implement segment().
-  * vector: Introduce segmentMove() method to move data inside of a vector.
-  * vector: Introduce shrink() function to shrink vector size without loosing data.
-  * Move CorrType type from Transceiver to sigProcLib.
-  * sigProcLib: rename signalError type to SignalError.
-  * Move Transceiver::detectBurst() to sigProcLib to make it reusable.
-  * Move BURST_THRESH from Transceiver.cpp to sigProcLib.h to make it reusable.
-  * sigProcLib: Add operator<< to print CorrType to a string.
-  * sigProcLib.h: Fix whitespaces. No non-whitespace changes.
-  * Move Transceiver::demodulate() to sigProcLib to make it reusable.
-  * sigProcLib: constify signalVector arguments for detectBurst() functions.
-  * sigProcLib: Constify demodulation functions burst argument.
-  * sigProcLib: Fix number of tail bits in random Normal Bursts and zero Stealing Bits.
-  * Configuration: Variables allocated with 'new' must be freed with 'delete'.
-  * BitVector: Remove Generator class.
-  * PRBS: a Pseudo-random binary sequence (PRBS) generator class.
-
-  [ Tom Tsou ]
-  * EDGE: Fix USRP B210 device support
-  * uhd: Correct timing alignment in 8-PSK and GMSK downlink bursts
-  * EDGE: Fix demodulation slicer input
-  * common: Restrict UDP binding to localhost only
-  * common: Add mandatory length field to UDP receive calls
-  * uhd: Update default E3XX settings
-  * uhd: Set default Tx sampling to 4 sps
-  * uhd: Make device offset check a private method
-  * uhd: Set minimum UHD version requirement for E3XX
-  * sigproc: Expand RACH, TSC, and EDGE correlation windows
-  * transceiver: Do not report error on SETTSC when radio is on
-  * transceiver: Add Rx samples-per-symbol option
-  * radioInterface: Convert diversity argument to general type
-  * iface: Add inner ring-buffer implementation
-  * mcbts: Add multi-ARFCN channelizing filters
-  * mcbts: Add multi-ARFCN radio support
-  * sigproc: Adjust burst detection threshold criteria
-  * egprs: Enable 8-PSK length vectors on the Tx interface
-  * egprs: Enable 8-PSK burst detection when EDGE is enabled
-  * transceiver: Remove HANDOVER warnings
-  * mcbts: Allow out of order channel setup
-  * radioInterface: Fix multi-channel buffer index bug
-  * uhd: Add command line option for GPS reference
-  * transceiver: Fix mixed GSMK / 8-PSK transmission
-  * transceiver: Fix 4 SPS receive TOA value
-  * sigproc: Fix missing 8-PSK tail symbols
-  * uhd: Update USRP2/N200/N210 for 4 SPS Rx
-  * sigproc: Match differential GMSK start/end bits to tail bits
-  * uhd: Add missing B200 sample timing for 4 SPS receive
-  * transceiver: Fix command build warning
-  * uhd: Set minimum supported version to 3.9.0
-  * uhd: Add X300 sample timing for 4 SPS
-  * Revert "uhd: Set minimum supported version to 3.9.0"
-  * uhd: Add support for UHD-3.11 logging control
-  * uhd: Increase MC-BTS FPGA clock rate to 51.2 MHz
-  * Resampler: Fix initialization return checking
-  * sigProcLib: Remove unreachable code and no-effect checks
-  * sigProcLib: Check return status on downsampling
-  * sigProcLib: Fix negative value check on unsigned value
-  * Resampler: Fix non-array delete for filter taps
-  * Transceiver: Remove unsigned negative compares
-  * Configuration: Fix const and signedness compile warnings
-  * config: Remove OpenBTS style sqlite configuration
-  * radioInterface: Remove UmTRX 'diversity' option
-  * build: Require and check for gcc C++11 support
-  * uhd: Use map container for for device parameter access
-  * sigProcLib: Remove unused functions from public interface
-  * uhd: Add non-UmTRX channel swap support
-  * uhd: Fix Tx-RX timing offset setting
-  * uhd: Fix USRP2/N200/N210 device detection
-  * transceiver: Fix POWEROFF crash on USRP2/N200/X300 devices
-  * sigProcLib: Fix complex/real vector flag in Laurent modulator
-  * sigProcLib: Remove heap based signal vector allocations
-  * common: Declare explicit Vector move constructor
-  * sigProcLib: Remove trigonometric tables
-  * sigProcLib: Use explicit NaN check in sinc table generation
-  * sigProcLib: Replace dynamically allocated resampling buffers
-  * sigProcLib: Specify standard namespace for isnan()
-  * uhd: Always specify samples-per-symbol for device lookup
-  * LimeSDR: set approximate tx offset value to make GSM work
-
-  [ Neels Hofmeyr ]
-  * add basic .gitignore
-  * configure.ac: check for boost/config.hpp header
-  * The INSTALL file is being overwritten by autoreconf, but it is committed as empty file. As a result, the INSTALL file always shows as modified. Instead, remove INSTALL from git and ignore it.
-  * add contrib/jenkins.sh, for gerrit build bot
-
-  [ pierre.baudry ]
-  * transceiver: Fix mismatched allocations and deallocations
-
-  [ Holger Hans Peter Freyther ]
-  * debian: Require fftw3 header files for osmo-trx
-
-  [ Max ]
-  * Add gerrit settings
-  * Integrate Debian packaging changes
-  * Remove embedded sqlite3
-  * Fix building against sqlite3
-  * Add autoconf-archive to dependencies
-  * debian: remove obsolete dependency
-  * deb: remove unused dependency
-  * Remove redundant explicit dependency
-  * Use release helper from libosmocore
-
-  [ Ruben Undheim ]
-  * Do not embed sqlite3 when building
-
-  [ Philipp Maier ]
-  * buildenv: Turn off native architecture builds
-  * cosmetic: Make parameter lists uniform
-  * Add test program to verify convolution implementation
-  * ssedetect: Add runtime CPU detection
-  * cosmetic: remove code duplication
-  * buildenv: Make build CPU invariant
-  * buildenv: Split up SSE3 and SSE4.1 code
-  * cosmetic: Add info about SSE support
-
-  [ Vadim Yanitskiy ]
-  * buildenv: correct the ax_sse macro description
-  * buildenv: actually strip unused cpuid functionality
-  * buildenv: fix build on systems without SIMD support
-  * buildenv: cosmetic changes
-  * buildenv: check for __builtin_cpu_supports call support
-  * ssedetect: call __builtin_cpu_supports() only if supported
-
-  [ Pau Espin Pedrol ]
-  * cosmetic: transciever: Remove trailing whitespaces
-  * transceiver: Avoid sending clock indications when trx is not powered on
-  * Add -j option to bind to specific address
-
-  [ ignasj ]
-  * LimeSDR: Change device detection to work with USB and PCIe versions
-  * LimeSDR: change tx window type to TX_WINDOW_FIXED
-  * LimeSDR: Fix sample value range
-
-  [ Harald Welte ]
-  * Add '-t' command line option to enable SCHED_RR
-  * Import git-version-gen and update AC_INIT()
-
- -- Harald Welte <laforge@gnumonks.org>  Sat, 28 Oct 2017 17:52:32 +0200
-
-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

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

debian/control

@@ -1,45 +0,0 @@
-Source: osmo-trx
-Section: net
-Priority: optional
-Maintainer: Ivan Klyuchnikov <ivan.kluchnikov@fairwaves.ru>
-Build-Depends: debhelper (>= 9),
-               autotools-dev,
-               autoconf-archive,
-               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}
-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

@@ -1,161 +0,0 @@
-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.