def compress(inp, bitout): """ Set up encoder and model. In this PPM model, symbol 256 represents EOF. Its frequency is 1 in the order -1 context but its frequency is 0 in all other contexts (which have non-negative order). """ enc = arithmeticcoding.ArithmeticEncoder(32, bitout) model = ppmmodel.PpmModel(MODEL_ORDER, 257, 256) history = [] while True: # Read and encode one byte symbol = inp.read(1) if len(symbol) == 0: break symbol = symbol[0] encode_symbol(model, history, symbol, enc) model.increment_contexts(history, symbol) if model.model_order >= 1: # Prepend current symbol, dropping oldest symbol if necessary if len(history) == model.model_order: history.pop() history.insert(0, symbol) encode_symbol(model, history, 256, enc) # EOF # Flush remaining code bits enc.finish()
def entropy_coding(frame_index, lat, path_bin, latent, sigma, mu): if lat == 'mv': bias = 50 else: bias = 100 bin_name = 'f' + str(frame_index).zfill(3) + '_' + lat + '.bin' bitout = arithmeticcoding.BitOutputStream(open(path_bin + bin_name, "wb")) enc = arithmeticcoding.ArithmeticEncoder(32, bitout) for h in range(latent.shape[1]): for w in range(latent.shape[2]): for ch in range(latent.shape[3]): mu_val = mu[0, h, w, ch] + bias sigma_val = sigma[0, h, w, ch] symbol = latent[0, h, w, ch] + bias freq = arithmeticcoding.logFrequencyTable_exp( mu_val, sigma_val, np.int(bias * 2 + 1)) enc.write(freq, symbol) enc.finish() bitout.close() bits_value = os.path.getsize(path_bin + bin_name) * 8 return bits_value
def main(args): # Argumentu apdorojimas if len(args) != 3: sys.exit("Usage: python ac-compress.py InputFile OutputFile BitsNum") input_file, output_file, bits_len = args[0], args[1], int(args[2]) if bits_len < 1 or bits_len > 124: print bits_len, bits_len < 1, bits_len > 124 sys.exit("Neleistina numBits reiksme, galimos reiksmes: [1 .. 124]") # Failo skaitymas ir dazniu lenteles sudarymas freqs = get_frequencies(input_file) enc = arithmeticcoding.ArithmeticEncoder(bits_len) max_total = enc.maximum_total freq_total = freqs.get_total() if freq_total > max_total: print( "Kumuliatyvus dazniu lenteles dydis yra perdidelis nuruodytam kodavimo intervalui." ) print("Pradedama dazniu lenteles normalizacija.") freqs.normalize_freq_table(max_total) # sys.exit() # Failas skaitomas antra karta, pritaikomas aritmetiko kodavimas suspaudymas ir sukuriamas isvesties failas with open(input_file, "rb") as inp, \ contextlib.closing(bitIO.BitOutputStream(open(output_file, "wb"))) as outp: write_header(outp, bits_len, freqs.get_bits_length()) write_frequencies(outp, freqs, freqs.get_bits_length()) # rasoma dazniu lentele enc.set_bitout(outp) compress(freqs, inp, enc) # suspaudzia duomenys
def compress(inp, bitout): # Set up encoder and model. In this PPM model, symbol 256 represents EOF; # its frequency is 1 in the order -1 context but its frequency # is 0 in all other contexts (which have non-negative order). enc = arithmeticcoding.ArithmeticEncoder(bitout) model = ppmmodel.PpmModel(MODEL_ORDER, 257, 256) history = [] while True: # Read and encode one byte symbol = inp.read(1) if len(symbol) == 0: break symbol = symbol[0] if python3 else ord(symbol) encode_symbol(model, history, symbol, enc) model.increment_contexts(history, symbol) if model.model_order >= 1: # Append current symbol or shift back by one if len(history) == model.model_order: del history[0] history.append(symbol) encode_symbol(model, history, 256, enc) # EOF enc.finish() # Flush remaining code bits
def compress(quantized, output_file): """ Function to load d Input: filename : Input hdf5 file consisting of training dataset Output: dataframe of paths to images dataset """ data = pickle.dumps(quantized) with open(output_file, "wb") as file: bitout = arithmeticcoding.BitOutputStream(file) initfreqs = arithmeticcoding.FlatFrequencyTable(257) freqs = arithmeticcoding.SimpleFrequencyTable(initfreqs) enc = arithmeticcoding.ArithmeticEncoder(32, bitout) i = 0 while i < len(data): # Read and encode one byte symbol = data[i] i += 1 enc.write(freqs, symbol) freqs.increment(symbol) enc.write(freqs, 256) # EOF enc.finish() # Flush remaining code bits
def start(self, dictionary_size=256): self.dictionary_size = dictionary_size self.bitout = arithmeticcoding.BitOutputStream( open(self.outputfile, "wb")) #self.freqsTable = arithmeticcoding.SimpleFrequencyTable([float(i % 8 + 1) for i in range(self.dictionary_size + 1)]) self.freqsTable = arithmeticcoding.FlatFrequencyTable( self.dictionary_size + 1) self.encoder = arithmeticcoding.ArithmeticEncoder(32, self.bitout)
def compress(freqs, inp, bitout): enc = arithmeticcoding.ArithmeticEncoder(32, bitout) while True: symbol = inp.read(1) if len(symbol) == 0: break enc.write(freqs, symbol[0]) enc.write(freqs, 256) # EOF enc.finish() # Flush remaining code bits
def compress(model): bit_out = arithmeticcoding.BitOutputStream(open('./result/data.bin', "wb")) enc = arithmeticcoding.ArithmeticEncoder(bit_out) # model = GenRNN(input_size=1, hidden_size=opt.hidden_size, output_size=len(characters), n_layers=opt.num_layers) # device = t.device(opt.device) # model.load_state_dict(t.load('./checkpoints/net_{}.pth'.format(opt.model_name, opt.chunk_len))) z = open('./result/old.txt', 'w') # model = model.to(device) # model.eval() hidden = None num_line = 0 sum_all = 0 time_num = 0 acc_num = 0 end_freq = generate_freqs(pro=1, first_step=True) with open('./result/test.qs') as f: while True: text = f.readline().replace('\n', '') z.write(text) z.write('\n') if not text: break encode_text = [char2int[char] for char in text] num_line += 1 hidden = None for char_index in range(len(encode_text)): if char_index == 0: freq = generate_freqs(pro=1, first_step=True) sum_all += -np.log2(1 / 35.) time_num += 8.0 # enc.write(freq, encode_text[char_index]) else: target_char = np.array(encode_text[char_index]) context_char = np.array(encode_text[char_index - 1]) out, hidden = predict(model, context_char, hidden) out = out[0] # (35, ) sum_all += -np.log2(out[target_char]) time_num += 8.0 freq = generate_freqs(pro=out, first_step=False) if np.argmax(out) == target_char.astype(np.int): acc_num += 1 enc.write(freq, encode_text[char_index]) end_freq = freq # enc.write(end_freq, 40) if num_line % 100 == 0: print(num_line) if num_line > 10000: break freq = generate_freqs(pro=1, first_step=True) # print(end_freq) enc.write(end_freq, len(characters)) enc.finish() print(acc_num / time_num, sum_all / time_num)
def compress(inp, bitout): initfreqs = arithmeticcoding.FlatFrequencyTable(257) freqs = arithmeticcoding.SimpleFrequencyTable(initfreqs) enc = arithmeticcoding.ArithmeticEncoder(32, bitout) while True: # Read and encode one byte symbol = inp.read(1) if len(symbol) == 0: break enc.write(freqs, symbol[0]) freqs.increment(symbol[0]) enc.write(freqs, 256) # EOF enc.finish() # Flush remaining code bits
def comparess(file1, model, indices_char): #this is painfully slow #if at all possible it should be revised so that it can mostly be run on the gpu #by painfully slow i mean on the order of .02 seconds per character guess. #ie ~16 minutes for a 50k character file. f1 = open(file1, 'r').read() data_size = len(f1) i = 0 #output = [0, f1[0]] bitout = arithmeticcoding.BitOutputStream(open(file1 + '.comp', "wb")) initfreqs = arithmeticcoding.FlatFrequencyTable(AE_SIZE) freqs = arithmeticcoding.SimpleFrequencyTable(initfreqs) enc = arithmeticcoding.ArithmeticEncoder(bitout) guesses_right = 0 gss = '' while i < data_size: current = ord(f1[i]) if i < maxlen: enc.write(freqs, 0) # Always 'guessing' zero correctly before maxlen freqs.increment(0) enc.write(freqs, current) freqs.increment(current) else: guess = predict(f1[(i - maxlen):i], model, indices_char) if (f1[i] == guess and guesses_right < 255): guesses_right += 1 print("Guessed", f1[i], "correctly") else: enc.write(freqs, guesses_right) print("Wrong guess. Outputing", guesses_right, "correct guesses") freqs.increment(guesses_right) print(i, "Outputing char", current) enc.write(freqs, current) freqs.increment(current) guesses_right = 0 if (i % 100 == 0): print("i:", i) i += 1 if guesses_right > 0: enc.write(freqs, guesses_right) enc.write(freqs, MAGIC_EOF) print("out eof sanity check") enc.finish() bitout.close() return None
def compress(inp, bitout): pmf = [0.2, 0.1, 0.3, 0.2, 0.2] pmf_new = [0.2, 0.1, 0.1, 0.3, 0.3] pmf = pmf_quantization(pmf) pmf_new = pmf_quantization(pmf_new) freqs = arithmeticcoding.ContextFrequencyTable(pmf) #freqs = arithmeticcoding.SimpleFrequencyTable(initfreqs) enc = arithmeticcoding.ArithmeticEncoder(32, bitout) for symbol in inp: # Read and encode one byte enc.write(freqs, symbol) freqs.increment(pmf_new) enc.write(freqs, 4) # EOF enc.finish() # Flush remaining code bits
def compress(snp, numsymbol): initfreqs = arithmeticcoding.FlatFrequencyTable(numsymbol) freqs = arithmeticcoding.SimpleFrequencyTable(initfreqs) enc = arithmeticcoding.ArithmeticEncoder(32) snp = np.squeeze(snp) rows,cols,channel = snp.shape for c in range(channel): for i in range(rows): for j in range(cols): # Read and encode one byte symbol = snp[i,j,c] enc.write(freqs, symbol) freqs.increment(symbol) enc.write(freqs, numsymbol-1) # EOF enc.finish() # Flush remaining code bits return enc.bit_nums
def compress(self, inp, freqs, num_symbols): enc = arithmeticcoding.ArithmeticEncoder() for i in range(len(inp)): symbol = inp[i] enc.write(freqs, symbol) enc.write(freqs, num_symbols) # EOF self.s = enc.finish() # Flush remaining code bits return self.s # Writes an unsigned integer of the given bit width to the given stream. # def write_int(bitout, numbits, value): # for i in reversed(range(numbits)): # bitout.write((value >> i) & 1) # Big endian # Main launcher #if __name__ == "__main__": # main(sys.argv[1 : ])
def compressTree( self, node, overall_freqs, N ): #n is the number of nodes in the hidden layer and pw is the list of all the normalized probability; use cummulative frequencies, then, #won't have to normalize enc = arithmeticcoding.ArithmeticEncoder() q = deque([node]) #self.j = 0 while len(q) != 0: temp = q.popleft() if temp.v > 1: tempValue = temp.v i = 0 for child in temp.childNodes: if child != None: if tempValue > 0: q.append(child) binomial_frequencies = ec( ).binomial_encoder_frequencies( overall_freqs[i:], tempValue ) # binomial encoder can convert to frequencies. convert to binary independently and check compression ratio for confirming correct amount of compression freqs = arithmeticcoding.SimpleFrequencyTable( binomial_frequencies) enc.write(freqs, child.v) tempValue = tempValue - child.v #a = a + '1011' i += 1 #print('Compressing Tree...',self.j) #self.j += 1 #print (i) elif temp.v == 1: for child in temp.childNodes: if child != None: if child.v == 1: symbol = child.c q.append(child) freqs = arithmeticcoding.SimpleFrequencyTable( overall_freqs) enc.write(freqs, symbol) compressed_tree = enc.finish() return compressed_tree
def compress(inp, bitout): # Set up encoder and model enc = arithmeticcoding.ArithmeticEncoder(bitout) model = ppmmodel.PpmModel(MODEL_ORDER, 257, 256) history = [] while True: # Read and encode one byte symbol = inp.read(1) if len(symbol) == 0: break symbol = symbol[0] if python3 else ord(symbol) encode_symbol(model, history, symbol, enc) model.increment_contexts(history, symbol) if model.model_order >= 1: # Append current symbol or shift back by one if len(history) == model.model_order: del history[0] history.append(symbol) encode_symbol(model, history, 256, enc) # EOF enc.finish() # Flush remaining code bits
def openFileLeft(self): enc = arithmeticcoding.ArithmeticEncoder(self.bitoutL) return enc
def encode(self, model_type, input_path, compressed_file_path, quality_level): # with TOP N dimensions img = Image.open(input_path) w, h = img.size fileobj = open(compressed_file_path, mode='wb') buf = quality_level << 1 buf = buf + model_type arr = np.array([0], dtype=np.uint8) arr[0] = buf arr.tofile(fileobj) arr = np.array([w, h], dtype=np.uint16) arr.tofile(fileobj) fileobj.close() new_w = int(math.ceil(w / 16) * 16) new_h = int(math.ceil(h / 16) * 16) pad_w = new_w - w pad_h = new_h - h input_x = np.asarray(img) input_x = np.pad(input_x, ((pad_h, 0), (pad_w, 0), (0, 0)), mode='reflect') input_x = input_x.reshape(1, new_h, new_w, 3) input_x = input_x.transpose([0, 3, 1, 2]) h_s_out, y_hat, z_hat, sigma_z = self.sess.run( [self.h_s_out, self.y_hat, self.z_hat, self.sigma_z], feed_dict={self.input_x: input_x}) # NCHW ############### encode z #################################### bitout = arithmeticcoding.BitOutputStream( open(compressed_file_path, "ab+")) enc = arithmeticcoding.ArithmeticEncoder(bitout) printProgressBar(0, z_hat.shape[1], prefix='Encoding z_hat:', suffix='Complete', length=50) for ch_idx in range(z_hat.shape[1]): printProgressBar(ch_idx + 1, z_hat.shape[1], prefix='Encoding z_hat:', suffix='Complete', length=50) mu_val = 255 sigma_val = sigma_z[ch_idx] # exp_sigma_val = np.exp(sigma_val) freq = arithmeticcoding.ModelFrequencyTable(mu_val, sigma_val) for h_idx in range(z_hat.shape[2]): for w_idx in range(z_hat.shape[3]): symbol = np.rint(z_hat[0, ch_idx, h_idx, w_idx] + 255) if symbol < 0 or symbol > 511: print("symbol range error: " + str(symbol)) # print(symbol) enc.write(freq, symbol) # enc.write(freq, 512) # enc.finish() # bitout.close() ############### encode y #################################### padded_y1_hat = np.pad(y_hat[:, :self.M1, :, :], ((0, 0), (0, 0), (3, 0), (2, 1)), 'constant', constant_values=((0, 0), (0, 0), (0, 0), (0, 0))) # bitout = arithmeticcoding.BitOutputStream(open(enc_outputfile, "wb")) # enc = arithmeticcoding.ArithmeticEncoder(bitout) c_prime = h_s_out[:, :self.M1, :, :] sigma2 = h_s_out[:, self.M1:, :, :] padded_c_prime = np.pad(c_prime, ((0, 0), (0, 0), (3, 0), (2, 1)), 'constant', constant_values=((0, 0), (0, 0), (0, 0), (0, 0))) printProgressBar(0, y_hat.shape[2], prefix='Encoding y_hat:', suffix='Complete', length=50) for h_idx in range(y_hat.shape[2]): printProgressBar(h_idx + 1, y_hat.shape[2], prefix='Encoding y_hat:', suffix='Complete', length=50) for w_idx in range(y_hat.shape[3]): c_prime_i = self.extractor_prime(padded_c_prime, h_idx, w_idx) c_doubleprime_i = self.extractor_doubleprime( padded_y1_hat, h_idx, w_idx) concatenated_c_i = np.concatenate([c_doubleprime_i, c_prime_i], axis=1) pred_mean, pred_sigma = self.sess.run( [self.pred_mean, self.pred_sigma], feed_dict={self.concatenated_c_i: concatenated_c_i}) zero_means = np.zeros([ pred_mean.shape[0], self.M2, pred_mean.shape[2], pred_mean.shape[3] ]) concat_pred_mean = np.concatenate([pred_mean, zero_means], axis=1) concat_pred_sigma = np.concatenate([ pred_sigma, sigma2[:, :, h_idx:h_idx + 1, w_idx:w_idx + 1] ], axis=1) for ch_idx in range(self.M): mu_val = concat_pred_mean[0, ch_idx, 0, 0] + 255 sigma_val = concat_pred_sigma[0, ch_idx, 0, 0] # exp_sigma_val = np.exp(sigma_val) freq = arithmeticcoding.ModelFrequencyTable( mu_val, sigma_val) symbol = np.rint(y_hat[0, ch_idx, h_idx, w_idx] + 255) if symbol < 0 or symbol > 511: print("symbol range error: " + str(symbol)) enc.write(freq, symbol) enc.write(freq, 512) enc.finish() bitout.close() return compressed_file_path
def inferenceNN( self, x, M, N, overall_freqs, L, activationFunction ): #N is the number of hidden nodes, the weights are of dimension MxN y = [0 for i in range(N)] enc = arithmeticcoding.ArithmeticEncoder() dec = arithmeticcoding.ArithmeticDecoder(L) q = deque([N]) #q_node = deque([node]) self.w = 0 tot_queue_length = floor(2 * log2(N + 1) + 1) max_queue_length = floor(2 * log2(N + 1) + 1) current_queue_length = floor(2 * log2(N + 1) + 1) j = 0 level = 0 flag = 0 flagp = 0 k = len(overall_freqs) print('M:', M, 'N:', N) while len(q) != 0 and level < M: currentNodeValue = q.popleft() current_queue_length -= floor(2 * log2(currentNodeValue + 1) + 1) if flagp == 0: print('current_queue_length', current_queue_length) flagp = 1 #currentnode = q_node.popleft() if currentNodeValue > 1: c = 0 #colour initialized with 0 while c <= k - 1 and currentNodeValue > 0: #kth colour need not be encoded binomial_frequencies = ec().binomial_encoder_frequencies( overall_freqs[c:], currentNodeValue) freqs = arithmeticcoding.SimpleFrequencyTable( binomial_frequencies) childNodeValue = dec.read(freqs) #if childNodeValue != currentnode.childNodes[c].v: # print('Not Matching!', childNodeValue, currentnode.childNodes[c].v) #else: # print('No problems here') enc.write(freqs, childNodeValue) currentNodeValue -= childNodeValue q.append(childNodeValue) current_queue_length += floor(2 * log2(childNodeValue + 1) + 1) max_queue_length = max(max_queue_length, current_queue_length) tot_queue_length += current_queue_length self.w += 1 #q_node.append(currentnode.childNodes[c]) #print('childNodeValue',childNodeValue) if childNodeValue > 0: flag = 1 for i in range(childNodeValue): # print('level:',level,'x[level]',x[level]) # print('Calculating Y....', level,':',self.w) y[j + i] += uc().index_to_weight(c) * x[level] #print(x[level], c) #y[j+i] += c*x[level] c = c + 1 j = (j + childNodeValue) % N if j == 0 and flag: level = level + 1 #print('level:',level) flag = 0 elif currentNodeValue == 1: freqs = arithmeticcoding.SimpleFrequencyTable(overall_freqs) c = dec.read(freqs) enc.write(freqs, c) q.append(1) current_queue_length += 3 max_queue_length = max(max_queue_length, current_queue_length) tot_queue_length += current_queue_length self.w += 1 y[j + i] += uc().index_to_weight(c) * x[level] j = (j + 1) % N if j == 0: level += 1 avg_queue_length = tot_queue_length / self.w L1 = enc.finish() #return L1 if needed y = np.array(y) if activationFunction == 'ReLU': y = uc().ReLU(y) elif activationFunction == 'sigmoid': y = uc().sigmoid(y) elif activationFunction == None: y = y return y, avg_queue_length, max_queue_length
def encode(self, model_type, input_path, compressed_file_path, quality_level): # with TOP N dimensions img = Image.open(input_path) w, h = img.size fileobj = open(compressed_file_path, mode='wb') buf = quality_level << 1 buf = buf + model_type arr = np.array([0], dtype=np.uint8) arr[0] = buf arr.tofile(fileobj) arr = np.array([w, h], dtype=np.uint16) arr.tofile(fileobj) fileobj.close() new_w = int(math.ceil(float(w) / 2.0) * 2) new_h = int(math.ceil(float(h) / 2.0) * 2) pad_w = new_w - w pad_h = new_h - h img_array = np.asarray(img) img_array = np.pad(img_array, ((0, pad_h), (0, pad_w), (0, 0)), mode='edge') input_x = img_array input_x = input_x.reshape(1, new_h, new_w, 3) input_x = input_x.transpose([0, 3, 1, 2]) gah1, sigma_z = self.sess.run([self.gah1, self.sigma_z], feed_dict={self.input_x: input_x}) gah1 = np.pad(gah1, ((0, 0), (0, gah1.shape[1] % 2), (0, gah1.shape[2] % 2), (0, 0)), mode='constant') gah2 = self.sess.run(self.gah2, feed_dict={self.gah1: gah1}) gah2 = np.pad(gah2, ((0, 0), (0, gah2.shape[1] % 2), (0, gah2.shape[2] % 2), (0, 0)), mode='constant') gah3 = self.sess.run(self.gah3, feed_dict={self.gah2: gah2}) gah3 = np.pad(gah3, ((0, 0), (0, gah3.shape[1] % 2), (0, gah3.shape[2] % 2), (0, 0)), mode='constant') y_hat = self.sess.run(self.y_hat, feed_dict={self.gah3: gah3}) y_w = y_hat.shape[3] y_h = y_hat.shape[2] new_y_w = int(math.ceil(float(y_w) / 4.0) * 4) new_y_h = int(math.ceil(float(y_h) / 4.0) * 4) pad_y_w = new_y_w - y_w pad_y_h = new_y_h - y_h pad_y_hat = np.pad(y_hat, ((0, 0), (0, 0), (0, pad_y_h), (0, pad_y_w)), mode='symmetric') z_hat, c_prime = self.sess.run([self.z_hat, self.c_prime], feed_dict={self.y_hat: pad_y_hat}) ############### encode zhat #################################### printProgressBar(0, z_hat.shape[1], prefix='Encoding z_hat:', suffix='Complete', length=50) bitout = arithmeticcoding.BitOutputStream( open(compressed_file_path, "ab+")) enc = arithmeticcoding.ArithmeticEncoder(bitout) for ch_idx in range(z_hat.shape[1]): printProgressBar(ch_idx + 1, z_hat.shape[1], prefix='Encoding z_hat:', suffix='Complete', length=50) mu_val = 255 sigma_val = sigma_z[ch_idx] freq = arithmeticcoding.ModelFrequencyTable(mu_val, sigma_val) for h_idx in range(z_hat.shape[2]): for w_idx in range(z_hat.shape[3]): symbol = np.int(z_hat[0, ch_idx, h_idx, w_idx] + 255) if symbol < 0 or symbol > 511: print("symbol range error: " + str(symbol)) enc.write(freq, symbol) ############### encode yhat #################################### padded_y_hat = np.pad(y_hat, ((0, 0), (0, 0), (3, 0), (2, 1)), 'constant', constant_values=((0, 0), (0, 0), (0, 0), (0, 0))) padded_c_prime = np.pad(c_prime, ((0, 0), (0, 0), (3, 0), (2, 1)), 'constant', constant_values=((0, 0), (0, 0), (0, 0), (0, 0))) printProgressBar(0, y_hat.shape[2], prefix='Encoding y_hat:', suffix='Complete', length=50) for h_idx in range(y_hat.shape[2]): printProgressBar(h_idx + 1, y_hat.shape[2], prefix='Encoding y_hat:', suffix='Complete', length=50) for w_idx in range(y_hat.shape[3]): c_prime_i = self.extractor_prime(padded_c_prime, h_idx, w_idx) c_doubleprime_i = self.extractor_doubleprime( padded_y_hat, h_idx, w_idx) concatenated_c_i = np.concatenate([c_doubleprime_i, c_prime_i], axis=1) pred_mean, pred_sigma = self.sess.run( [self.pred_mean, self.pred_sigma], feed_dict={self.concatenated_c_i: concatenated_c_i}) for ch_idx in range(self.M): mu_val = pred_mean[0, ch_idx, 0, 0] + 255 sigma_val = pred_sigma[0, ch_idx, 0, 0] freq = arithmeticcoding.ModelFrequencyTable( mu_val, sigma_val) symbol = np.int(y_hat[0, ch_idx, h_idx, w_idx] + 255) if symbol < 0 or symbol > 511: print("symbol range error: " + str(symbol)) enc.write(freq, symbol) enc.write(freq, 512) enc.finish() bitout.close() return compressed_file_path
def openFileRight(self): enc = arithmeticcoding.ArithmeticEncoder(self.bitoutR) return enc