def main():
file = open(sys.argv[1], "rb")
msg = ConstBitStream(file)
s_in = BitArray()
keys = {Bits(''): 0}
s_out = BitArray()
count = 1
n_bits = 0
while True:
try:
s_in.append(msg.read(1))
except ReadError:
break
#Se a palavra nao tiver no dicionario
if Bits(s_in) not in keys:
# x = yb
y = s_in[:-1]
b = s_in[-1:]
pos = keys[Bits(y)]
#log base 2 |keys|
n_bits = ceil(log2(len(keys)))
if n_bits != 0:
prefix = Bits(uint=int(pos), length=n_bits)
else:
prefix = Bits('')
s_out.append(Bits('0b' + str(prefix.bin) + str(b.bin)))
keys[Bits(s_in)] = count
count += 1
s_in.clear()
#Add padding: 00000 10101
#Numero de zeros é o tamanho dos bits extra para depois no descompressor saber
if s_in[:1].bin == Bits(1):
z = Bits('0b' + '0' * len(s_in))
else:
z = Bits('0b' + '1' * len(s_in))
s_in.reverse()
s_out.reverse()
s_out.append(s_in)
s_out.append(z)
s_out.reverse()
with open(sys.argv[2], 'wb') as f_out:
s_out.tofile(f_out)
file.close()
def __init__(self, N, szt, alpha, x, lam, theta, V=None):
#Collection of BitArrays
self.basis = []
self.N = N
self.szt = szt
self.x = x
self.lam = lam
self.alpha = alpha
self.theta = theta
if V is None:
self.V = theta * (2 * np.random.rand(N, 1) - 1)
else:
self.V = V
k = (2 * szt + N) // 2
#construct the basis as a set of bit strings
startingbit = BitArray('0b0')
startingbit.clear()
self.makeString(startingbit, N - k, k)
self.dim = len(self.basis)
def testClear(self):
s = BitArray('0xfff')
s.clear()
self.assertEqual(s.len, 0)
def testClear(self):
s = BitArray('0xfff')
s.clear()
self.assertEqual(s.len, 0)
def main():
file = open(sys.argv[1], "rb")
msg = ConstBitStream(file)
s_in = BitArray()
aux = BitArray()
keys = ['']
s_out = ''
s_in.append(msg.read(1))
aux = s_in.copy()
aux.invert(0)
count = 0
#Encontrar o tamanho do padding
while (s_in.bin) != aux.bin:
try:
count += 1
s_in.clear()
s_in.append(msg.read(1))
except ReadError:
break
padding = BitArray()
padding.append(s_in)
s_in = BitArray()
#Com o tamanho encontrar o padding correspondente
padding.append(msg.read(count - 1))
while True:
n_bits = ceil(log2(len(keys)))
try:
s_in.append(msg.read(n_bits + 1))
except ReadError:
break
y = s_in[:-1]
b = s_in[-1:]
if Bits(y) == Bits(''):
pos = 0
else:
pos = y.uint
s_out = s_out + (str(keys[pos]) + b.bin)
keys.append(str(keys[pos]) + str(Bits(b).bin))
s_in = BitArray()
output = BitArray('0b' + s_out)
output.append(padding)
with open(sys.argv[2], 'wb') as f_out:
output.tofile(f_out)
file.close()
class Framing():
"""Classe que representa o procedimento para alinhamento de quadro no PCM30
"""
def __init__(self, logging_level=logging.INFO):
self.buffer_octeto = BitArray(
) # Buffer utilizado somente no Estado Realinhando
self.buffer_frame = BitArray()
self.buffer_copy = BitArray()
self.n = 1 # número de quadros para avançar (inicia em 1)
# Configurando Logs
self.logger = logging.getLogger("Framming")
logging.basicConfig(level=logging_level)
# Definindo estado inicial
self.logger.info("Iniciando...")
self.state = State.REALIGNING
self._print_state()
self.logger.info("Procurando FAS...")
# Método chamado pela função principal
def handle_fsm(self, received_bit: bin):
"""Método para chamar a Máquina de estados passando os bits recebidos externamente
ou bits presentes no buffer.
Args:
received_bit (bin): bit 0 <'0b0'> ou 1 <'0b1'>
"""
self._fsm(received_bit)
# Após retornar da FSM só volta a ler o arquivo se o buffer tiver vazio
while len(self.buffer_copy) > 0: # Enquanto tiver bits no buffer
buffer_bit = self.buffer_copy.bin[0]
del self.buffer_copy[0:1:1]
self._fsm(self.char_to_bit(buffer_bit))
def _fsm(self, buffer_bit):
"""Método privado que representa a máquina de estados
Args:
received_bit : bit recebido
"""
# Estado REALINHANDO
if self.state is State.REALIGNING:
len_octeto = len(self.buffer_octeto)
if len_octeto < 8:
self.buffer_octeto.append(buffer_bit)
else:
# Deslizar octeto
del self.buffer_octeto[0:1:1] # Remove bit da primeira posição
self.buffer_octeto.append(
buffer_bit) # Insere novo bit na última
self.logger.debug("Octeto: %s" % self.buffer_octeto.bin)
if self.buffer_octeto.uint is Signal.FAS.value: # Verifica se temos um possível PAQ
self.logger.info("FAS confirmado, possível PAQ encontrado!")
self.state = State.REALIGNMENT_CHECK # Transição de Estado
self._print_state()
# Estado de confirmação de Realinhamento
elif self.state is State.REALIGNMENT_CHECK:
frame, octeto = self._go_to_frame(self.n, buffer_bit)
if frame == 1: # Avançou 1 quadro
b1_pos = 1
b1 = octeto.bin[b1_pos] # Recuperando b1 para comparação
self.logger.info("b1 (nfas) = %s" % b1)
self.logger.debug("Buffer = %s" % self.buffer_frame.bin)
if str(b1) == '1': # comparação do b1
self.logger.info("NFAS confirmado!")
self.logger.debug("Buffer = %s" % self.buffer_frame.bin)
self.n = 2 # avançar para próximo quadro
else:
self.logger.info("NFAS não confirmado, PAQ Inválido!")
self.state = State.REALIGNING # Transição de Estado
self.buffer_copy.clear()
self.buffer_copy = self.buffer_frame.copy()
self.logger.debug("Buffer Copy= %s" % self.buffer_copy.bin)
self.buffer_frame.clear()
self.n = 1
self._print_state()
self.logger.info("Procurando FAS...")
elif frame == 2: # Avançou 2 quadros
self.n = 1 # retornando n global para primeiro quadro
if octeto.uint is Signal.FAS.value: # Comparação do FAS
self.logger.info("FAS confirmado, PAQ Encontrado!")
self.logger.debug("Buffer = %s" % self.buffer_frame.bin)
self.state = State.ALIGNED # Transição de Estado
self._print_state()
self._get_information()
#limpando buffers
self.buffer_copy.clear()
self.buffer_frame.clear()
else:
self.logger.info("FAS não confirmado, PAQ Inválido!")
self.state = State.REALIGNING # Transição de Estado
self.buffer_copy.clear()
self.buffer_copy = self.buffer_frame.copy()
self.logger.debug("Buffer Copy= %s" % self.buffer_copy.bin)
self.buffer_frame.clear()
self._print_state()
self.logger.info("Procurando FAS...")
# Estado de Alinhamento
elif self.state is State.ALIGNED:
frame, octeto = self._go_to_frame(2,
buffer_bit) # Avançar 2 quadros
if frame == 2: # Avançou 2 quadros
if octeto.uint is Signal.FAS.value: # Comparação do FAS
self.logger.info("FAS confirmado, PAQ Encontrado!")
self._get_information()
self.state = State.ALIGNED # Transição de Estado
self.buffer_copy.clear()
self.buffer_frame.clear()
else:
self.logger.info("FAS não confirmado, PAQ Inválido!")
self.state = State.LOSS_ALIGNMENT_CHECK # Transição de Estado
self._print_state()
self.logger.info("Verificando perda do Alinhamento...")
self.logger.info("Procurando FAS...")
self.n = 4
# Estado de confirmação de perda do Alinhamento
elif self.state is State.LOSS_ALIGNMENT_CHECK:
frame, octeto = self._go_to_frame(self.n,
buffer_bit) # Avançar 2 quadros
if octeto: # Avançou quadros
if octeto.uint is Signal.FAS.value: # Comparação do FAS
self.logger.info("FAS confirmado, PAQ Encontrado!")
self.logger.info("Alinhamento recuperado!")
self.state = State.ALIGNED # Transição de Estado
self._print_state()
self._get_information()
self.n = 1
# limpando buffers
self.buffer_copy.clear()
self.buffer_frame.clear()
else:
if frame == 4: # Avançou 4 quadros
self.logger.info("FAS não confirmado, PAQ Inválido!")
self.state = State.LOSS_ALIGNMENT_CHECK # Transição de Estado
self.logger.info("Procurando FAS...")
self.n = 6
elif frame == 6: # Avançou 6 quadros
self.logger.info("FAS não confirmado, PAQ Inválido!")
self.logger.info("Perda do alinhamento confirmada!")
self.state = State.REALIGNING # Transição de Estado
self.buffer_copy.clear()
self.buffer_frame.clear()
self._print_state()
self.logger.info("Procurando FAS...")
self.n = 1
@staticmethod
def char_to_bit(char_bit: str) -> bin:
"""Função para converter um caractere em um bit
Args:
char_bit (str): caractere recebido para conversão
Returns:
bin: bit convertido
"""
if str(char_bit) == "0":
return '0b0'
elif str(char_bit) == "1":
return '0b1'
else:
print("Error char = %s" % char_bit)
def _go_to_frame(self, n_frame: int, buffer_bit: bin) -> [int, BitArray]:
"""Método privado responsável por avançar quadros
Args:
n_frame (int): número de quadros para avançar
buffer_bit (bin): bit para adicionar ao buffer
Returns:
int,BitArray: int --> número de quadros avançados
BitArray --> octeto com NFAS ou FAS para comparação
"""
self.buffer_frame.append(
buffer_bit) # Avançar bits até completar quadro
len_frame = len(self.buffer_frame)
if len_frame == (n_frame * 256): # Avançou n quadros
if n_frame > 1:
self.logger.info("Avançando 2 Quadros...")
else:
self.logger.info("Avançando 1 Quadro...")
start_pos = len_frame - 8 # (256 - 8)
nfas_or_fas = self.buffer_frame[
start_pos:] # recuperando NFAS ou FAS
if n_frame == 1:
self.logger.info("NFAS = %s" % nfas_or_fas.bin)
else:
self.logger.info("FAS = %s" % nfas_or_fas.bin)
self.logger.debug("Buffer = %s" % self.buffer_frame.bin)
return n_frame, nfas_or_fas
return 0, None
def _get_information(self):
"""Método privado responsável por imprimir na tela o conteúdo entre PAQs
"""
self.logger.info("Recuperando Informação...")
end_pos_info = len(self.buffer_frame) - 8 #(512 - 8)
information = self.buffer_frame[:
end_pos_info].bin # remover informação sem PAQ
text = "Informação entre PAQs\n"
text += "----------------------------------------\n"
text += "%s\n----------------------------------------" % information
self.logger.info(text)
self.logger.debug("Buffer = %s" % self.buffer_frame.bin)
def _print_state(self):
"""Método para imprimir os estados atuais durante a execução da Máquina
"""
self.logger.info("========================================")
self.logger.info("Estado = %s" % self.state.name)
self.logger.info("========================================")
class ByteBuffer(object):
'''
classdocs
'''
def __init__(self, arrIn=None):
'''
Constructor
'''
if arrIn is None:
self.dataList = []
else:
self.dataList = arrIn
self.currentPos = 0
self.mba = BitArray()
def add(self, byteIn):
self.dataList.append(byteIn)
def getbitArray(self, start, count):
self.mba.clear()
for index in range(start, start + count):
db = self.dataList[index]
if db < 0:
ashex = format(db & (2**8 - 1), '#04x')
self.mba.append(ashex)
else:
self.mba.append(format(db, '#04x'))
return self.mba
def get(self, index=None):
if index is None:
index = self.currentPos
self.currentPos += 1
return self.getbitArray(index, 1).intle
def getShort(self, index=None):
if index is None:
index = self.currentPos
self.currentPos += 2
mba = self.getbitArray(index, 2)
return mba.intle
def getUnsignedShort(self, index=None):
if index is None:
index = self.currentPos
self.currentPos += 2
mba = self.getbitArray(index, 2)
rtv = mba.uintle
return rtv
def getInt(self, index=None):
if index is None:
index = self.currentPos
self.currentPos += 4
mba = self.getbitArray(index, 4)
return mba.intle
def getUnsignedInt(self, index=None):
if index is None:
index = self.currentPos
self.currentPos += 4
mba = self.getbitArray(index, 4)
return mba.uintle
def getLong(self, index=None):
if index is None:
index = self.currentPos
self.currentPos += 8
mba = self.getbitArray(index, 8)
return mba.intle
def getFloat(self, index=None):
if index is None:
index = self.currentPos
self.currentPos += 4
mba = self.getbitArray(index, 4)
return mba.floatle
def getDouble(self, index=None):
if index is None:
index = self.currentPos
self.currentPos += 8
mba = self.getbitArray(index, 8)
return mba.floatle
