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 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