Osmocom Libraries » libosmocore

class ConvolutionalCode(object):

	def __init__(self, block_len, k, polys, name=None, description=None):

		# Save simple params

		self.block_len = block_len

		self.k = k

		self.rate_inv = len(polys)

		# Infos

		self.name = name

		self.description = description

		# Handle polynoms (and check for recursion)

		self.polys = [(1,1) if x[0]==x[1] else x for x in polys]

		rp = [x[1] for x in self.polys if x[1] != 1]

		if rp:

			if not all([x == rp[0] for x in rp]):

				raise ValueError("Bad polynoms: Can't have multiple different divider polynoms !")

			if not all([x[0]==1 for x in polys if x[1]==1]):

				raise ValueError("Bad polynoms: Can't have a '1' divider with a non '1' dividend in a recursive code")

			self.poly_divider = rp[0]

		else:

			self.poly_divider = 1

	@property

	def recursive(self):

		return self.poly_divider != 1

	def _combine(self, src, sel, nb):

		x = src & sel

		fn_xor = lambda x,y: x^y

		return reduce(fn_xor, [(x >> n) & 1 for n in range(nb)])

	@property

	def _state_mask(self):

		return ((1<<(self.k-1)) - 1)

	def next_state(self, state, bit):

		nb = self._combine(

			(state << 1) | bit,

			self.poly_divider,

			self.k,

		)

		return ((state << 1) | nb) & self._state_mask

	def next_term_state(self, state):

		return (state << 1) & self._state_mask

	def next_output(self, state, bit, ns=None):

		# Next state bit

		if ns is None:

			ns = self.next_state(state, bit)

		src  = (ns & 1) | (state << 1)

		# Scan polynoms

		rv = []

		for p_n, p_d in self.polys:

			if self.recursive and p_d == 1:

				o = bit	# No choice ... (systematic output in recursive case)

			else:

				o = self._combine(src, p_n, self.k)

			rv.append(o)

		return rv

	def next_term_output(self, state, ns=None):

		# Next state bit

		if ns is None:	

			ns = self.next_term_state(state)

		src = (ns & 1) | (state << 1)

		# Scan polynoms

		rv = []

		for p_n, p_d in self.polys:

			if self.recursive and p_d == 1:

				# Systematic output are replaced when in 'termination' mode

				o = self._combine(src, self.poly_divider, self.k)

			else:

				o = self._combine(src, p_n, self.k)

			rv.append(o)

		return rv

	def next(self, state, bit):

		ns = self.next_state(state, bit)

		nb = self.next_output(state, bit, ns=ns)

		return ns, nb

	def next_term(self, state):

		ns = self.next_term_state(state)

		nb = self.next_term_output(state, ns=ns)

		return ns, nb

	def gen_tables(self):

		pack = lambda n: sum([x << (self.rate_inv-i-1) for i,x in enumerate(n)])

		num_states = 1 << (self.k-1)

		# next_output

		print "--- [next output]"

		for state in range(num_states):

			print "{ %2d, %2d }, " % (

				pack(self.next_output(state, 0)),

				pack(self.next_output(state, 1))

			)

		# next_state

		print "--- [next state]"

		for state in range(num_states):

			print "{ %2d, %2d }, " % (

				self.next_state(state, 0),

				self.next_state(state, 1)

			)

		if self.recursive:

			# next_term_output

			print "--- [next term output]"

			d = []

			for state in range(num_states):

				d.append("%2d,%s" % (

					pack(self.next_term_output(state)),

					'\n' if state % 16 == 15 else ' ',

				))

			print "{"

			print ''.join(d)

			print "};"

			# next_term_state

			print "--- [next term state]"

			d = []

			for state in range(num_states):

				d.append("%2d,%s" % (

					self.next_term_state(state),

					'\n' if state % 16 == 15 else ' ',

				))

			print "{"

			print ''.join(d)

			print "};"

poly = lambda *args: sum([(1<<x) for x in args])

# 228 bits blocks, rate 1/2, k=5

#  G0 = 1 + D3 + D4

#  G1 = 1 + D + D3 + D4

xcch_code = ConvolutionalCode(

	224, 5,

	[

		( poly(0,3,4),		1 ),

		( poly(0,1,3,4),	1 ),

	],

)

# 124 bits

#  G4/G6 = 1 + D2 + D3 + D5 + D6 / 1 + D + D2 + D3 + D4 + D6

#  G5/G6 = 1 + D + D4 + D6 / 1 + D + D2 + D3 + D4 + D6

#  G6/G6 = 1

#  G6/G6 = 1

tch_afs_5_9_code = ConvolutionalCode(

	124, 7,

	[

		( poly(0,2,3,5,6),	poly(0,1,2,3,4,6) ),

		( poly(0,1,4,6),	poly(0,1,2,3,4,6) ),

		( 1,				1),

		( 1,				1),

	],

)

#  G1 = 1 + D           + D4

#  G2 = 1     + D2 + D3 + D4

#  G3 = 1 + D + D2      + D4

#  G4 = 1 + D      + D3 + D4

tetra_rcpc_code = ConvolutionalCode(

	288, 5,

	[

		( poly(0,1,4),		1 ),

		( poly(0,2,3,4),	1 ),

		( poly(0,1,2,4),	1 ),

		( poly(0,1,3,4),	1 ),

	],

)

tetra_rcpc_tch_code = ConvolutionalCode(

	288, 5,

	[

		( poly(0,1,2,3,4),		1 ),

		( poly(0,1,3,4),		1 ),

		( poly(0,2,4),			1 ),

	],

)