def encode_reed_salomon(arr): arr_shape = arr.shape arr.resize(arr.size) rs = reedsolo.RSCodec(4) reedsolo.RSCodec() size_mod = arr.size % 4 rs_code = numpy.empty(arr.size * 2 - size_mod, numpy.uint8) for x in range(0, arr.size - size_mod, 4): rs_code[2 * x:2 * x + 8] = numpy.frombuffer( rs.encode(arr[x:x + 4].tobytes()), numpy.uint8) for x in range(size_mod): rs_code.itemset((arr.size - size_mod) * 2 + x, arr.item(arr.size - size_mod + x)) arr.resize(arr_shape) return rs_code
def test_reed_solomon_encoding(self): # fmt: off pairs = [("a0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebf", "0404992ae0b12cb0ef0d4fd3"), ("11a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbd11bf", "e001803c2130884c190d57d5"), ("22a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbd22bf", "6c32056dd3fcc33fa6193773"), ("0a1a2a3a4a5a6a7a8a9aaabacadaeafa0b1b2b3b4b5b6b7b8b9babbbcbdbebfb", "08149eef461af628943c2661"), ("b3f455fb0b275123dec0e73c4becca19246bf2b103df401844a3bdcd3fd01a95", "500409183fa1b8e680568da7"), ("435777773fb1e36f7d6b5f1e99afaa7a57f16be0ed36bc057c7dae6a266d1504", "815d3007153d797bd6630d0e"), ("20a126c10f50ee871f43cfcfe4e62a492e3f729a6c48348a58863f3a482a69fe", "36150928f41dcacf396c0893"), ("a8d5fbda18d75605c422d2b10ac7f73283a5c9609d6b8c90ffaa96b84f133582", "a4f21330282242c9e20b6acf"), ("4296abb9a44432c8656d5605feffc25d71941fd0abf0ff0d61a01a19315a264c", "1bb4c3afd14b9023b33a2f15"), ("206e4f83f8173635d7d554d96b84586fbc3a4280b4403cba5834d3dc8e99a682", "1b7edac989c569cb08f9efd9"), ("57e8dc1b37c6b53a428fc6d7242114eaf3d80b0447bb642703120a257cf7ec52", "5ee82f785f3d5e19df92635b"), ("ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff", "13a36292597404257375e0aa"), ("f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0", "f66cb1ba3ee5d164a19668a0"), ("abad1deaabad1deaabad1deaabad1deaabad1deaabad1deaabad1deaabad1dea", "1171924a9b34c16878e182a5"), ("abad1deadeadbeefabadbabecafebabe11223344556677889900aabbccddeeff", "7601266085196663727c6522"), ("0000000000000000000000000000000000000000000000000000000000000000", "000000000000000000000000"), ("1000000000000000000000000000000000000000000000000000000000000000", "b6f06eae2266cc0bfca685ca"), ("0001000100010001000a000b000c000d000e000f000100010001000100010001", "6dc2afb4820bb002d9263544"), ("0000000000000000000000000000000000000000000000000000000000000001", "44774376dc1f07545c7fd561"), ] # Pregenerated pairs consisting of 32 bytes of data + 12 bytes of RS ECC (FPGA verified) # fmt: on rs = reedsolo.RSCodec(12) # 12 ECC symbols for pair in pairs: bin_base = bytearray.fromhex(pair[0]) # Encode the original 32 bytes of data encoded_data = rs.encode([x for x in bin_base]) self.assertEqual(encoded_data, bytearray.fromhex(pair[0] + pair[1]))
def extract(storage_path: str, output_path: str): """ Used to extract data from the specified directory at the storage path, and will write the extracted data to a file at the specified output path. """ encoded_int_strings = CovertChannel.get_encoded_int_string( storage_path) found_start = False next_index = 0 encoded_data = bytearray() files_remaining = 0 files_captured = 0 for string in sorted(encoded_int_strings): index = int(string[0:DIGITS_FOR_INDEX]) if index != 0: if not found_start: continue elif files_remaining > 0: files_remaining -= 1 files_captured += 1 byte = bytearray(int_to_bytes( int(string[DIGITS_FOR_INDEX:]))) newbyte = bytes(byte) while len(newbyte) < STORABLE_BYTES_PER_FILE: newbyte = b'\x00' + bytes(newbyte) encoded_data += bytearray(newbyte) next_index += 1 else: break else: found_start = True files_remaining = int(string[DIGITS_FOR_INDEX:]) next_index = 1 files_captured += 1 print('Found data for {} files'.format(files_captured)) # Trim leading zero bytes while bytes(encoded_data)[0] == 0: encoded_data = encoded_data[1:] # Decode the message from ECC message decoded_message = reedsolo.RSCodec( ERROR_CORRECTING_BYTES).decode(encoded_data) # Retrieve original file extension message_and_data = decoded_message.rsplit(b'.', 1) message = message_and_data[0] ext = message_and_data[1] to_save = open(output_path + '.' + ext.decode("utf-8"), 'wb') to_save.write(message)
def datagram_received(self, data, addr): global time_data_recieved_start global time_data_recieved_and_loaded time_data_recieved_start = time.time() time_fec_starts = 0 if (fec > 0): rs = reedsolo.RSCodec(fec) time_fec_starts = time.time() data = rs.decode(data) time_json_start = time.time() original_message = json.loads(data.decode()) time_for_fec_and_dejson_end = time.time() if addr not in self.qs.keys(): self.qs[addr] = queue.PriorityQueue(maxsize=2000) pqs.append(self.qs[addr]) # print("recieved data") add_packets_to_queue(self.qs[addr], original_message) time_data_recieved_and_loaded = time.time() time_packet_sync_start = time.time() tuples = time_sync() end_time = time.time() analyze_tuples(tuples, end_time, time_data_recieved_start, \ time_data_recieved_and_loaded, time_packet_sync_start, \ time_for_fec_and_dejson_end, time_fec_starts, time_json_start) # print("Close the socket") self.transport.close()
def fix_data_errors(self): for data_row, error_correction_row in self.error_correction_sequence.rows(): values = [cw.value for cw in data_row + error_correction_row] rs = reedsolo.RSCodec(len(error_correction_row)) corrected = rs.decode(values) for cw, value in zip(data_row, corrected): cw.value = value
def __init__(self): self.map = self.get_map() self.chars = sorted(self.map.keys()) self.dsp = Signal(self.RATE) self.rs = reedsolo.RSCodec(nsym=8, nsize=20, prim=0x25, generator=2, c_exp=5)
def rs_encode(self, payload): """ Reed Solomon Error Correction Encoding """ rsl = self.get_rs_length(len(payload)) padded = [0] * (255 - rsl) for i in range(0, len(payload)): padded[i] = payload[i] rs = reedsolo.RSCodec(nsym=rsl, fcr=1) encoded = payload[:] encoded.extend(list(rs.encode(padded))[-rsl:]) return encoded
def main(argv): inputfile = '' original_file = '' indices_file = '' try: opts, args = getopt.getopt(argv, "h:d:i:o:", ["dfile=", "itype=", "ofile="]) except getopt.GetoptError: print 'file.py -d <file_to_decode> -o <original_file> -i <indices_file>' sys.exit(2) for opt, arg in opts: print opt, arg, if opt == '-h': print 'file.py -d <file_to_decode> -o <original_file> -i <indices_file> ' sys.exit() elif opt in ("-d", "--dfile"): inputfile = arg elif opt in ("-i", "--itype"): indices_file = arg elif opt in ("-o", "--ofile"): original_file = arg else: print "check help for usage" sys.exit() print inputfile print inputfile.split('_') to_decode_file = scipy.fromfile(open(inputfile), dtype=scipy.float32) original_string = scipy.fromfile(open(original_file), dtype=scipy.float32) oracle_indices = np.load(indices_file) print "\n lengths for measured data:", len( to_decode_file), "length of orig transmission: ", len(original_string) get_index = start_index(to_decode_file) start_data_index = get_index + 1 # get_index+1 #(m-get_index) #m - (len(preamble) - get_index) +1 print "starting of data is ", start_data_index plt.plot(to_decode_file[:start_data_index], '*-') plt.savefig('abhinav.pdf') plt.clf() original_message = original_string[len(preamble):] to_decode_data1 = to_decode_file[start_data_index:] to_decode_data = to_decode_data1.astype(np.int64) #print "lengths of data going in:", len(original_message), len(to_decode_data) #bin_rep_to_decode=decoding_maj3(oracle_indices,to_decode_data) bin_rep_to_decode = single_demod(oracle_indices, to_decode_data) ber_single(oracle_indices, to_decode_data, original_message) print "\nGoing to decode" rs = reedsolo.RSCodec(32) message_decoded = '' try: message_decoded = rs.decode(bin_rep_to_decode) except: print "Cannot decode using RS decoder " print "decoded message is ", message_decoded print "\n"
def __init__(self, sym_bits=5, block_len=20, code_ratio=0.8): self.sym_bits = sym_bits self.block_len = block_len self.code_ratio = code_ratio self.msg_len = int(block_len * code_ratio) self.ecc_len = self.block_len - self.msg_len self.prim = reedsolo.find_prime_polys(c_exp=self.sym_bits) self.codec = reedsolo.RSCodec(nsym=self.ecc_len, prim=self.prim[0], nsize=self.block_len, c_exp=self.sym_bits)
def removeErrorCorrection(data): completeData = bytes(b'') for element in data: completeData += bytes(element) rs = reedsolo.RSCodec(40) dataDecoded = rs.decode(completeData) #dataDecoded = completeData return dataDecoded
def burn_key(esp, args, data=None): block_num = args.key_block + BLOCK_BY_NAME["BLOCK_KEY0"][1] block = BLOCKS[block_num] purpose_num = KEY_PURPOSES.index(args.purpose) if data is None: data = args.file.read() if len(data) != 32: raise esptool.FatalError( "File must be exactly 32 bytes (this file was %d)" % (len(data))) if args.purpose in [ "XTS_AES_256_KEY_1", "XTS_AES_256_KEY_2", "XTS_AES_128_KEY" ]: print("Reversing byte order for AES-XTS hardware peripheral...") data = data[::-1] # apply RS encoding rs = reedsolo.RSCodec(12) encoded_data = rs.encode([x for x in data]) # 32 byte of data + 12 bytes RS words = struct.unpack("<" + "I" * 11, encoded_data) # write key data _clear_pgm_registers(esp) for i in range(8): esp.write_reg(EFUSE_PGM_DATA0_REG + 4 * i, words[i]) for i in range(3): esp.write_reg(EFUSE_CHECK_VALUE0_REG + 4 * i, words[i + 8]) _efuse_program(esp, block_num) # write purpose register for the key block _clear_pgm_registers(esp) _, purpose_word, purpose_mask, purpose_wr_dis_bit = BLK0_BY_NAME[ "KEY_PURPOSE_%d" % args.key_block] esp.write_reg(EFUSE_PGM_DATA0_REG + 4 * purpose_word, purpose_num << _shift(purpose_mask)) _efuse_program(esp, 0) print("Write protecting purpose efuse and key block...") _, _, _, blk_rd_dis_bit, blk_wr_dis_bit = block _clear_pgm_registers(esp) new_wr_dir = (1 << blk_wr_dis_bit) | (1 << purpose_wr_dis_bit) esp.write_reg(EFUSE_PGM_DATA0_REG, new_wr_dir) _efuse_program(esp, 0) errs, fail = _get_block_errors(esp, block_num) if errs == 0 and not fail: print("(No encoding errors in block)") else: print("WARNING: Block has %d errors (failed=%s)" % (errs, fail)) print("Done")
def _decodeData(data): decoder = reedsolo.RSCodec(7) data=decoder.decode(data)[:19] heximal = "" for i in data: heximal+="{:02X}".format(i) heximal=heximal[3:] while heximal[-1:]!="0": heximal = heximal[:-2] heximal=heximal[:-1] bytesarr=bytearray.fromhex(heximal) return bytesarr
def img2data(image, width, height, bucket, q, metaDataSize, metaDataOffset, enSize, modulation_type): """ insert in blocks """ from . import video_helper_functions as vhf import reedsolo if modulation_type == "square_RGB": dataOut = functions.demodulate_Square_RGB_Fast(image, width, height, bucket, q) elif modulation_type == "square_YUV": dataOut = functions.demodulate_Square_YUV_Fast(image, width, height, bucket, q) elif modulation_type == "square_YUV2": dataOut = functions.demodulate_Square_YUV_Fast2( image, width, height, bucket, q) else: raise Exception("modulation type not supported") # Get metadata totMetaDataSize = metaDataSize + 8 * enSize metaData = dataOut[:totMetaDataSize] # Handle Reed-Solomon if needed # THIS MIGHT NOT WORK if enSize != 0: metaData = bytearray(vhf.bit_array_2_bytes(metaData)) rs = reedsolo.RSCodec(enSize) metaData = vhf.bytes_2_bit_list(rs.decode(metaData)) new_frame, index, offset, bitoffset = vhf.extract_metadata( metaData, metaDataOffset) if (0): print("\n%%%%") print("index", index) print("offset", offset) print("bitoffset", bitoffset) print("length", len(dataOut)) print("metadata len", totMetaDataSize) print("%%%%\n") # cut up data message = dataOut[totMetaDataSize:totMetaDataSize + offset] size = totMetaDataSize + offset - bitoffset if 0: print(vhf.bit_array_2_bytes(dataOut[:totMetaDataSize + offset])) return message[:len(message) - bitoffset], new_frame, index, offset, bitoffset, size
def rs_decode(self, payload, length): """ Reed Solomon Error Correction Decoding """ padded = [0] * 255 for i in range(0, length): padded[i] = payload[i] parity = payload[length:] for i in range(0, len(parity)): padded[255 - len(parity) + i] = parity[i] try: rs = reedsolo.RSCodec(nsym=len(parity), fcr=1) return list(rs.decode(padded))[:length] except reedsolo.ReedSolomonError: print('Decode failed')
def __init__(self, bits_per_symbol, preamble=None, log_ber_interval=10, spy_length=64, spy_threshold=0.1): ModulatorClassic.__init__(self, bits_per_symbol, max_amplitude=0.09) gr.basic_block.__init__(self, name="modulator_classic", in_sig=None, out_sig=None) # Echo protocol variables assert preamble is not None, "Preamble must be provided" if preamble is not np.ndarray: preamble = np.array(preamble) self.preamble = preamble self.preamble_si = util_data.bits_to_integers(self.preamble, self.bits_per_symbol) self.log_ber_interval = log_ber_interval # Message port setup and variables self.port_id_in = pmt.intern("bits") self.port_id_update = pmt.intern("update") self.port_id_out = pmt.intern("symbols") self.message_port_register_in(self.port_id_in) self.message_port_register_in(self.port_id_update) self.message_port_register_out(self.port_id_out) self.set_msg_handler(self.port_id_in, self.handle_packet) self.set_msg_handler(self.port_id_update, self.handle_update) self.packet_cnt = 0 self.ber_cnt = 0 # Packet header and spy variables self.spy_length = spy_length assert self.spy_length % self.bits_per_symbol == 0 self.spy_threshold = spy_threshold self.reedsolomon = reedsolo.RSCodec(4) self.rs_length = 4 * 2 * 8 # 4 bytes data, 4 bytes parity, 8 bits per byte # Logging stuff self.uuid = uuid.uuid4() self.uuid_str = str(self.uuid)[-6:] self.logger = gr.logger("log_debug") self.logger.set_level("DEBUG") self.logger.info("classic mod {}: {} bits per symbol".format( self.uuid_str, self.bits_per_symbol)) with open("ber_echo_{}.csv".format(self.uuid_str), "w") as f: f.write("train_iter,BER\n")
def decode_reed_salomon(arr, shape): rs = reedsolo.RSCodec(4) size_mod = arr.size % 4 arr_out = numpy.empty(shape, numpy.uint8) arr_out.resize(arr_out.size) for i in range(0, arr_out.size - size_mod, 4): try: arr_out[i:i + 4] = numpy.frombuffer( rs.decode(arr[2 * i:2 * i + 8].tobytes()), numpy.uint8) except reedsolo.ReedSolomonError: arr_out[i:i + 4] = arr[2 * i:2 * i + 4] for i in range(size_mod): arr_out.iteset(arr_out.size - size_mod + i, arr.item((arr_out.size - size_mod) * 2 + i)) arr_out.resize(shape) return arr_out
def encodeRS(arr): arrShape = arr.shape # storing shape arr.resize(arr.size) rs = reedsolo.RSCodec(4) sizeMod = arr.size % 4 arr_out = numpy.empty(arr.size * 2 - sizeMod, numpy.uint8) for i in range(0, arr.size - sizeMod, 4): # looping through 4byte chunks in arr arr_out[2 * i:2 * i + 8] = numpy.frombuffer( rs.encode(arr[i:i + 4].tobytes()), numpy.uint8) #inserting the encoded bytes into the output array for i in range(sizeMod): arr_out.itemset((arr.size - sizeMod) * 2 + i, arr.item(arr.size - sizeMod + i)) arr.resize(arrShape) return arr_out
def datagram_received(self, data, addr): message = data.decode() # print('Received %r from %s' % (message, addr)) # print("sending json_data", json_data) data = data_generator(original_time, fps) json_data = json.dumps(data).encode() if (fec > 0): rs = reedsolo.RSCodec(fec) reed_data = rs.encode(json_data) if network_delay_transmitter_to_client_over_udp > 0: time.sleep(network_delay_transmitter_to_client_over_udp) self.transport.sendto(reed_data, addr) else: if network_delay_transmitter_to_client_over_udp > 0: time.sleep(network_delay_transmitter_to_client_over_udp) self.transport.sendto(json_data, addr)
def __init__(self, bits_per_symbol, block_length=10000, preamble=None, log_ber_interval=10, spy_length=64, spy_threshold=0.1, alias="demod_classic"): DemodulatorClassic.__init__(self, bits_per_symbol=bits_per_symbol, block_length=block_length, max_amplitude=0.09) gr.basic_block.__init__(self, name="demod_classic", in_sig=None, out_sig=None) self.alias = alias self.port_id_in = pmt.intern("symbols") self.port_id_out = pmt.intern("bits") self.port_id_corrupt = pmt.intern("corrupt") self.message_port_register_in(self.port_id_in) self.message_port_register_out(self.port_id_out) self.message_port_register_out(self.port_id_corrupt) self.set_msg_handler(self.port_id_in, self.handle_packet) if preamble is not np.ndarray: preamble = np.array(preamble) self.preamble = preamble self.packet_cnt = 0 self.update_cnt = 0 self.ber = None self.log_ber_interval = log_ber_interval self.spy_length = spy_length assert self.spy_length % self.bits_per_symbol == 0 self.spy_threshold = spy_threshold self.reedsolomon = reedsolo.RSCodec(4) self.rs_length = 4 * 2 * 8 # 4 bytes data, 4 bytes parity, 8 bits per byte self.uuid = uuid.uuid4() self.uuid_str = str(self.uuid)[-6:] self.logger = gr.logger("log_debug") self.logger.set_level("DEBUG") self.logger.info("classic demod {}: {} bits per symbol".format( self.uuid_str, self.bits_per_symbol)) with open("ber_{}.csv".format(self.uuid_str), "w") as f: f.write("iter,BER\n")
def handle_coding_scheme(self, blk, data): if blk.id != 0: # CODING_SCHEME RS applied only for all blocks except BLK0. coded_bytes = 12 data.pos = coded_bytes * 8 plain_data = data.readlist('32*uint:8')[::-1] # takes 32 bytes # apply RS encoding rs = reedsolo.RSCodec(coded_bytes) # 32 byte of data + 12 bytes RS calc_encoded_data = list(rs.encode([x for x in plain_data])) data.pos = 0 if calc_encoded_data != data.readlist('44*uint:8')[::-1]: raise FatalError("Error in coding scheme data") data = data[coded_bytes * 8:] if blk.len < 8: data = data[(8 - blk.len) * 32:] return data
def apply_coding_scheme(self): data = self.get_raw(from_read=False)[::-1] if len(data) < self.len_of_burn_unit(): add_empty_bytes = self.len_of_burn_unit() - len(data) data = data + (b"\x00" * add_empty_bytes) if self.get_coding_scheme() == self.parent.REGS.CODING_SCHEME_RS: # takes 32 bytes # apply RS encoding rs = reedsolo.RSCodec(12) # 32 byte of data + 12 bytes RS encoded_data = rs.encode([x for x in data]) words = struct.unpack("<" + "I" * 11, encoded_data) # returns 11 words (8 words of data + 3 words of RS coding) else: # takes 32 bytes words = struct.unpack("<" + ("I" * (len(data) // 4)), data) # returns 8 words return words
def decodeRS(arr, shape): rs = reedsolo.RSCodec(4) sizeMod = arr.size % 4 arr_out = numpy.empty(shape, numpy.uint8) arr_out.resize(arr_out.size) for i in range(0, arr_out.size - sizeMod, 4): # looping through 8byte chunks in arr try: arr_out[i:i + 4] = numpy.frombuffer( rs.decode(arr[2 * i:2 * i + 8].tobytes()), numpy.uint8 ) #inserting the decoded bytes into the output array except reedsolo.ReedSolomonError: arr_out[i:i + 4] = arr[2 * i:2 * i + 4] for i in range(sizeMod): arr_out.iteset(arr_out.size - sizeMod + i, arr.item((arr_out.size - sizeMod) * 2 + i)) arr_out.resize(shape) return arr_out
class Share: rs = reedsolo.RSCodec(10) def __init__(self, raw_value, batch): raw_value = "".join(raw_value.split()) self.raw_value = raw_value.replace("-", "") self.batch = batch self.code = "" try: decoded = self.rs.decode(bytes.fromhex(self.raw_value)) except Exception: return if len(decoded) == 33: as_string = decoded.hex() self.code = as_string[0:2] + "-" + as_string[2:] def __eq__(self, other): return self.raw_value == other.raw_value and \ self.batch == other.batch
def get_values(m): rs_bytes = 20 codec = reedsolo.RSCodec(rs_bytes) try: with open("lpn.key", "r") as f: key = json.loads(f.read()) key['pk'][0] = deserialize_mat(key['pk'][0]) key['pk'][1] = deserialize_mat(key['pk'][1]) key['sk'] = deserialize_mat(key['sk']) except IOError as e: assert e.strerror == 'No such file or directory' key = MultiBitKeyGen(800) with open("lpn.key", "w") as f: f.write(serialize_key(key)) ctxt = MultiBitEnc(key['pk'], bytes(codec.encode(m))) ptxt = codec.decode(bytearray(MultiBitDec(key['sk'], ctxt))) return (key, ctxt, ptxt)
def insertErrorCorrection(inputFile): if os.path.isfile(inputFile): f = open(inputFile, "rb") data = f.read() f.close() # add redundancy: each 215 bytes we add 40 ecc bytes and get a new chunk size of 255 bytes (~15% redundancy) # with this behaviour we share the redundancy over the entire input message and thus over different timestamps rs = reedsolo.RSCodec(40) #print(data) print(len(data)) dataEncoded = rs.encode(data) #print(dataEncoded) print(len(dataEncoded)) return dataEncoded else: print("No regular file.") return 0
def brute_force(blocks, limit_error_correction, unknown_code_nums, unknown_indexes, verbose): brute_range = unknown_code_nums - limit_error_correction_num assert (brute_range <= BF_LIMIT) assert (len(unknown_indexes) >= brute_range) target_indexes = unknown_indexes[0:brute_range] if verbose: print '[*] start bruteforce(%d bytes)' % brute_range print '[*] target indexes' + repr(target_indexes) # reverse for using reedsolomon module blocks.reverse() target_indexes = map(lambda x: len(blocks) - 1 - x, target_indexes) brute_bytes_range = 1 << 8 * brute_range for i in xrange(brute_bytes_range): candidates = i for j in xrange(brute_range): blocks[target_indexes[j]] = candidates % 0x100 candidates >>= 8 try: # is it always true? rs = reedsolo.RSCodec(limit_error_correction_num * 2) #print repr(bytearray(blocks)) corrected = rs.encode(rs.decode(bytearray(blocks))) assert (len(corrected) == len(blocks)) # only one solution is possible? for i in xrange(len(blocks)): blocks[i] = corrected[i] blocks.reverse() return except Exception, e: #raise pass #print bytearray(blocks) if i % 0x1000 == 0 and verbose: print "[*] processing 0x%x/0x%x" % (i, brute_bytes_range)
def img2meta(image, width, height, bucket, q, metaDataSize, metaDataOffset, enSize, modulation_type): from . import video_helper_functions as vhf import reedsolo import sys import traceback try: totMetaDataSize = metaDataSize + 8 * enSize if modulation_type == "square_RGB": dataOut = functions.demodulate_Square_RGB_Fast_Meta( image, width, height, bucket, q, totMetaDataSize) elif modulation_type == "square_YUV": dataOut = functions.demodulate_Square_YUV_Fast_Meta( image, width, height, bucket, q, totMetaDataSize) else: print("Unsupported img2meta modulation_type") # Get metadata metaData = dataOut[:totMetaDataSize] metaData = bytearray(vhf.bit_array_2_bytes(metaData)) if enSize != 0: # Set up Reed-Solomon rs = reedsolo.RSCodec(enSize) metaData = vhf.bytes_2_bit_list(rs.decode(metaData)) else: metaData = vhf.bytes_2_bit_list(metaData) new_frame, index, offset, bitoffset = vhf.extract_metadata( metaData, metaDataOffset) return new_frame, index, offset, bitoffset except Exception as e: import sys, traceback print("Exception in img2meta") print(e) print(traceback.print_tb(sys.exc_info()[2]))
def encode_barcode(data): crc = caurus._crc24(data) data += crc.to_bytes(3, 'big') if len(data) != _BLOCK_SIZE - _ECC_SYMBOLS: raise Exception('Unsupported size') rs = reedsolo.RSCodec(nsym=_ECC_SYMBOLS, nsize=_BLOCK_SIZE, fcr=1) data = rs.encode(data) modules = [] for i in range(_BLOCK_SIZE): for block in range(len(data) // _BLOCK_SIZE): for j in range(0, 8, 2)[::-1]: modules.append((data[block * _BLOCK_SIZE + i] >> j) & 0b11) modules[-3] = 0 result = [] offset = 0 for alignment, take in caurus._ALIGNMENT: result += alignment result += modules[offset:offset + take] offset += take return result
def read_audio_packets(f): nop = 32 audio_packets = [] for i in range(nop): header = bytearray(f.read(7)) if len(header) < 7 or header[0] != 0xff or header[1] & 0xf0 != 0xf0: return audio_packets length = (header[3] & 0x03) << 11 | (header[4] << 3) | (header[5] >> 5) packet = bytearray(f.read(length - 7)) audio_packets.append(packet) return audio_packets rs = reedsolo.RSCodec(8) NUM_FRAMES = 32 fpsd = [open('psd{0}.raw'.format(channel + 1), 'rb') for channel in range(8)] faudio = open('sample.hdc', 'rb') with open('p1.raw', 'wb') as fout: start_seq_no = 0 for frame in range(NUM_FRAMES): pdu_seq_no = frame % 2 p1_bytes = bytearray() for channel in range(3): if channel == 0: audio_packets = read_audio_packets(faudio) else:
def __init__(self, nsym): Ecc.__init__(self, nsym) self.coder = reedsolo.RSCodec(self.nsym)