def decode(file,
error_correction=nocode,
null_is_terminator=False,
mode_1_bmp=False,
number_of_chunks=STATIC_NUM_CHUNKS,
use_header_chunk=False,
id_len_format=ID_LEN_FORMAT,
number_of_chunks_len_format=NUMBER_OF_CHUNKS_LEN_FORMAT,
packet_len_format=PACKET_LEN_FORMAT,
crc_len_format=CRC_LEN_FORMAT,
read_all=READ_ALL_BEFORE_DECODER,
distribution_cfg_str=""):
dist = ErlichZielinskiRobustSolitonDistribution(number_of_chunks,
seed=2)
if distribution_cfg_str != "":
# parse distribution_cfg_str and create distribution with the defined settings...
splt = distribution_cfg_str.split("_")
mode = splt[1]
if mode == "ErlichZielinskiRobustSoliton":
k = int(splt[2].split("=")[1])
delta = float(splt[3].split("=")[1])
c = float(splt[4].split("=")[1])
dist = ErlichZielinskiRobustSolitonDistribution(k,
delta,
c,
seed=2)
elif mode == "RobustSoliton":
k = int(splt[2].split("=")[1])
delta = float(splt[3].split("=")[1])
dist = RobustSolitonDistribution(number_of_chunks,
k,
delta,
seed=2)
elif mode == "IdealSoliton":
dist = IdealSolitonDistribution(number_of_chunks, seed=2)
"""try:
decoder = LTBPDecoder(file, error_correction=error_correction, use_headerchunk=HEADER_CHUNK,
static_number_of_chunks=STATIC_NUM_CHUNKS, implicit_mode=IMPLICIT_MODE, dist=dist)
print("[1/2] Approximation Decode")
_internal(decoder)
if not decoder.is_decoded():
print("[2/2] Approximation Decode")
_internal(decoder)
decoder.saveDecodedFile(null_is_terminator=NULL_IS_TERMINATOR)
except Exception as e:"""
print("[X/2] Falling back to Gauss-Mode")
print("Falling back to Gauss-Mode")
decoder = LTDecoder(file,
error_correction=error_correction,
use_headerchunk=use_header_chunk,
static_number_of_chunks=number_of_chunks,
implicit_mode=IMPLICIT_MODE,
dist=dist)
decoder.read_all_before_decode = read_all
decoder.decode(number_of_chunks_len_format=number_of_chunks_len_format,
seed_len_format=id_len_format,
degree_len_format="H")
decoder.solve()
decoder.saveDecodedFile(null_is_terminator=null_is_terminator,
print_to_output=PRINT_TO_OUTPUT)
def blackboxTest(file, number_of_chunks=800, droprate=0.02, seed=2):
print(
"#### Starting Blackbox Test with "
+ str(number_of_chunks)
+ " Chunks and a droprate of "
+ str(droprate)
+ " ####"
)
start = time.time()
dist = IdealSolitonDistribution(number_of_chunks, seed)
pseudo = LTBPDecoder.pseudo_decoder(number_of_chunks)
encoder = LTEncoder(file, number_of_chunks, dist, pseudo_decoder=pseudo)
decoder = LTDecoder.pseudo_decoder(number_of_chunks)
result, numberOfEncodedPackets, dropedCount = blackbox(
encoder, decoder, droprate=droprate
)
end = time.time() - start
print(
"Blackbox-Decode "
+ ("successful" if result else "NOT successful")
+ " after "
+ str(round(end, 4))
+ " sec."
)
return ["LT", result, numberOfEncodedPackets, dropedCount, round(end, 4)]
def blackboxTest(file,
number_of_chunks=800,
droprate=0.02,
seed=2,
overhead=0.05):
print("#### Starting Blackbox Test with " + str(number_of_chunks) +
" Chunks and a droprate of " + str(droprate) + " ####")
start = time.time()
dist = RobustSolitonDistribution(S=number_of_chunks, seed=seed)
# dist = IdealSolitonDistribution(S=number_of_chunks, seed=seed)
# pseudo = LTBPDecoder.pseudo_decoder(number_of_chunks)
encoder = LTEncoder(file, number_of_chunks,
dist) # , pseudo_decoder=pseudo)
decoder = LTDecoder.pseudo_decoder(number_of_chunks,
read_all_before_decode=True)
encoder.set_overhead_limit(overhead)
result, numberOfEncodedPackets, dropedCount, solvedCount = blackbox(
encoder, decoder, droprate=droprate)
end = time.time() - start
print("Blackbox-Decode " + ("successful" if result else "NOT successful") +
" after " + str(round(end, 4)) + " sec.")
return [
dist.get_config_string(),
result,
numberOfEncodedPackets,
dropedCount,
solvedCount,
round(end, 4),
number_of_chunks,
]
def blackboxLTIdealTest(file,
number_of_chunks=800,
seed=2,
chunk_size=0,
overhead=0.20,
scale=1.0):
print(bcolors.OK + "Starting Blackbox Test with " + str(number_of_chunks) +
" Chunks" + bcolors.ENDC)
start = time.time()
dist = IdealSolitonDistribution(S=number_of_chunks, seed=seed)
algo_type.clear()
algo_type.append("LT_" + str(number_of_chunks) + "_" +
str(dist.get_config_string()))
encoder = LTEncoder(file, number_of_chunks, dist, chunk_size=chunk_size)
encoder.set_overhead_limit(overhead)
decoder = LTDecoder.pseudo_decoder(number_of_chunks)
decoder.set_read_all_before_decode(True)
result, dec_input, invalid_drop = blackbox(encoder, decoder, scale=scale)
end = time.time() - start
print(bcolors.BLUE + "Blackbox-Decode " +
(bcolors.OK + "successful" if result else bcolors.ERR +
"NOT successful") + bcolors.END + bcolors.BLUE + " after " +
str(round(end, 4)) + " sec." + bcolors.ENDC)
return [
dist.get_config_string(),
result,
number_of_chunks,
dec_input,
invalid_drop,
round(end, 4),
]
def test_erlich_zielinski_dnarules():
dir_path = os.getcwd()
try:
os.remove(dir_path + "/DEC_" + out_dir2)
except:
print("Not deleting, File did not exists")
shutil.copyfile(dir_path + "/" + cmp_file2, dir_path + "/" + file2)
chunksize = 75
number_of_chunks = Encoder.get_number_of_chunks_for_file_with_chunk_size(
file2, chunksize)
pseudo_decoder = LTDecoder.pseudo_decoder(number_of_chunks)
dist = ErlichZielinskiRobustSolitonDistribution(k=number_of_chunks,
delta=0.2,
seed=2)
rules = DNARules_ErlichZielinski()
encoder = LTEncoder(file2,
number_of_chunks,
dist,
error_correction=reed_solomon_encode,
chunk_size=chunksize,
rules=rules,
insert_header=False,
number_of_chunks_len_format="H",
id_len_format="H",
used_packets_len_format="H",
pseudo_decoder=pseudo_decoder,
implicit_mode=True,
save_number_of_chunks_in_packet=False)
encoder.encode_to_packets()
encoder.save_packets(split_to_multiple_files=True, save_as_dna=True)
assert pseudo_decoder.is_decoded() and pseudo_decoder.getSolvedCount(
) == encoder.number_of_chunks
assert os.path.exists(out_dir2)
decoder = LTDecoder(out_dir2,
use_headerchunk=False,
dist=dist,
implicit_mode=True,
static_number_of_chunks=encoder.number_of_chunks,
error_correction=reed_solomon_decode)
decoder.decodeFolder(number_of_chunks_len_format="H",
seed_len_format="H",
degree_len_format="H")
assert decoder.is_decoded() and decoder.getSolvedCount(
) == encoder.number_of_chunks
decoder.saveDecodedFile(print_to_output=False, null_is_terminator=True)
out_file2 = "DEC_LT_" + file2
assert os.path.exists(out_file2) and filecmp.cmp(out_file2, cmp_file2)
os.remove(out_file2)
def init_dec(self):
"""
Gets the pseudodecoder based on the original class of the first packet in the packet list.
:return: Pseudodecoder
"""
packet = self.normal_packets[0]
if packet.get_org_class() == "RU10Packet":
return RU10Decoder.pseudo_decoder(packet.total_number_of_chunks)
elif packet.get_org_class() == "OnlinePacket":
return OnlineDecoder.pseudo_decoder(packet.total_number_of_chunks)
elif packet.get_org_class() == "Packet":
return LTDecoder.pseudo_decoder(packet.total_number_of_chunks)
def blackboxLTTest(file, number_of_chunks=800, seed=2, chunk_size=0):
print("Starting Blackbox Test with " + str(number_of_chunks) + " Chunks")
start = time.time()
dist = RobustSolitonDistribution(S=number_of_chunks, seed=seed)
pseudo = LTBPDecoder.pseudo_decoder(number_of_chunks)
encoder = LTEncoder(file,
number_of_chunks,
dist,
pseudo_decoder=pseudo,
chunk_size=chunk_size)
decoder = LTDecoder.pseudo_decoder(number_of_chunks)
result, numberOfEncodedPackets, dropedCount = blackbox(encoder, decoder)
end = time.time() - start
print("Blackbox-Decode " + ("successful" if result else "NOT successful") +
" after " + str(round(end, 4)) + " sec.")
return [
dist.get_config_string(),
result,
numberOfEncodedPackets,
dropedCount,
round(end, 4),
number_of_chunks,
]
def main(file):
print("###### LT Codec number_of_chunks = 700 ######")
print("##### Ideal Soliton Distribution #####")
print("### LT without prioritized Packets ###")
start = time.time()
number_of_chunks = 700
dist = IdealSolitonDistribution(number_of_chunks, seed=2)
encoder = LTEncoder(file, number_of_chunks, dist)
encoder.encode_to_packets()
end = time.time() - start
print("Finished encoding after " + str(round(end, 4)) + " sec. " +
str(len(encoder.get_encoded_packets())) + " Packets encoded.\n")
print("### LT without prioritized Packets with pseudo_decoder ###")
start = time.time()
number_of_chunks = 700
dist = IdealSolitonDistribution(number_of_chunks, seed=2)
pseudo = LTBPDecoder.pseudo_decoder(number_of_chunks)
encoder = LTEncoder(file, number_of_chunks, dist, pseudo_decoder=pseudo)
encoder.encode_to_packets()
end = time.time() - start
print("Finished encoding after " + str(round(end, 4)) + " sec. " +
str(len(encoder.get_encoded_packets())) + " Packets encoded.\n")
print("### LT with prioritized Packets ###")
start = time.time()
number_of_chunks = 700
dist = IdealSolitonDistribution(number_of_chunks, seed=2)
encoder = LTEncoder(file,
number_of_chunks,
dist,
prioritized_packets=[1, 3, 5])
encoder.encode_to_packets()
end = time.time() - start
print("Finished encoding after " + str(round(end, 4)) + " sec. " +
str(len(encoder.get_encoded_packets())) + " Packets encoded.\n")
print("### LT with prioritized Packets AND pseudo_decoder ###")
start = time.time()
number_of_chunks = 700
dist = IdealSolitonDistribution(number_of_chunks, seed=2)
pseudo = LTBPDecoder.pseudo_decoder(number_of_chunks)
encoder = LTEncoder(file,
number_of_chunks,
dist,
pseudo_decoder=pseudo,
prioritized_packets=[1, 3, 5])
encoder.encode_to_packets()
end = time.time() - start
print("Finished encoding after " + str(round(end, 4)) + " sec. " +
str(len(encoder.get_encoded_packets())) + " Packets encoded.\n")
print("### LT with prioritized Packets AND Gauss-pseudo_decoder ###")
start = time.time()
number_of_chunks = 700
dist = IdealSolitonDistribution(number_of_chunks, seed=2)
pseudo = LTDecoder.pseudo_decoder(number_of_chunks)
encoder = LTEncoder(file,
number_of_chunks,
dist,
pseudo_decoder=pseudo,
prioritized_packets=[1, 3, 5])
encoder.encode_to_packets()
end = time.time() - start
print("Finished encoding after " + str(round(end, 4)) + " sec. " +
str(len(encoder.get_encoded_packets())) + " Packets encoded.\n")
print("##### Robust Soliton Distribution #####")
print("### LT without prioritized Packets ###")
start = time.time()
number_of_chunks = 700
dist = RobustSolitonDistribution(number_of_chunks, seed=2)
encoder = LTEncoder(file, number_of_chunks, dist)
encoder.encode_to_packets()
end = time.time() - start
print("Finished encoding after " + str(round(end, 4)) + " sec. " +
str(len(encoder.get_encoded_packets())) + " Packets encoded.\n")
print("### LT without prioritized Packets with Gauss-pseudo_decoder ###")
start = time.time()
number_of_chunks = 700
dist = RobustSolitonDistribution(number_of_chunks, seed=2)
pseudo = LTDecoder.pseudo_decoder(number_of_chunks)
encoder = LTEncoder(file, number_of_chunks, dist, pseudo_decoder=pseudo)
encoder.encode_to_packets()
end = time.time() - start
print("Finished encoding after " + str(round(end, 4)) + " sec. " +
str(len(encoder.get_encoded_packets())) + " Packets encoded.\n")
print("### LT with prioritized Packets ###")
start = time.time()
number_of_chunks = 700
dist = RobustSolitonDistribution(number_of_chunks, seed=2)
encoder = LTEncoder(file,
number_of_chunks,
dist,
prioritized_packets=[1, 3, 5])
encoder.encode_to_packets()
end = time.time() - start
print("Finished encoding after " + str(round(end, 4)) + " sec. " +
str(len(encoder.get_encoded_packets())) + " Packets encoded.\n")
print("### LT with prioritized Packets AND Gauss-pseudo_decoder ###")
start = time.time()
number_of_chunks = 700
dist = RobustSolitonDistribution(number_of_chunks, seed=2)
pseudo = LTDecoder.pseudo_decoder(number_of_chunks)
encoder = LTEncoder(file,
number_of_chunks,
dist,
pseudo_decoder=pseudo,
prioritized_packets=[1, 3, 5])
encoder.encode_to_packets()
end = time.time() - start
print("Finished encoding after " + str(round(end, 4)) + " sec. " +
str(len(encoder.get_encoded_packets())) + " Packets encoded.\n")
print(
"###### Online Codec - number_of_chunks = 2500, eps=0.01, quality=3 ######"
)
print("### Online without pseudo_decoder ###")
start = time.time()
number_of_chunks = 2500
epsilon = 0.01
quality = 3
dist = OnlineDistribution(epsilon)
# infer number_of_chunks form Distribution:
number_of_chunks = dist.get_size()
pseudo = OnlineBPDecoder.pseudo_decoder()
encoder = OnlineEncoder(file, number_of_chunks, dist, epsilon, quality)
encoder.encode_to_packets()
end = time.time() - start
print("Finished encoding after " + str(round(end, 4)) + " sec. " +
str(len(encoder.get_encoded_packets())) + " Packets encoded.\n")
print("### Online with pseudo_decoder ###")
start = time.time()
number_of_chunks = 2500
epsilon = 0.01
quality = 3
dist = OnlineDistribution(epsilon)
# infer number_of_chunks form Distribution:
number_of_chunks = dist.get_size()
pseudo = OnlineBPDecoder.pseudo_decoder()
encoder = OnlineEncoder(file,
number_of_chunks,
dist,
epsilon,
quality,
pseudo_decoder=pseudo)
encoder.encode_to_packets()
end = time.time() - start
print("Finished encoding after " + str(round(end, 4)) + " sec. " +
str(len(encoder.get_encoded_packets())) + " Packets encoded.\n")
def test_suite(as_dna, decoder_instance, distribution, use_header,
implicit_mode):
dir_path = os.getcwd()
try:
os.remove(dir_path + "/" + file)
except:
print("Not deleting, File did not exists")
shutil.copyfile(dir_path + "/" + cmp_file, dir_path + "/" + file)
chunksize = 200
number_of_chunks = Encoder.get_number_of_chunks_for_file_with_chunk_size(
file, chunksize)
pseudo_decoder = decoder_instance.pseudo_decoder(number_of_chunks)
if distribution == "robust":
dist = RobustSolitonDistribution(S=number_of_chunks, delta=0.2, seed=2)
elif distribution == "ideal":
dist = IdealSolitonDistribution(S=number_of_chunks, seed=2)
else:
dist = ErlichZielinskiRobustSolitonDistribution(k=number_of_chunks,
delta=0.2,
seed=2)
rules = FastDNARules() if as_dna else None
encoder = LTEncoder(file,
number_of_chunks,
dist,
chunk_size=chunksize,
pseudo_decoder=pseudo_decoder,
rules=rules,
insert_header=use_header,
number_of_chunks_len_format="H",
id_len_format="H",
used_packets_len_format="H",
implicit_mode=implicit_mode)
encoder.encode_to_packets()
encoder.save_packets(split_to_multiple_files=True, save_as_dna=as_dna)
assert pseudo_decoder.is_decoded() and pseudo_decoder.getSolvedCount(
) == encoder.number_of_chunks
assert os.path.exists(out_dir)
decoder = decoder_instance(out_dir,
use_headerchunk=use_header,
dist=dist,
implicit_mode=implicit_mode)
decoder.decodeFolder(number_of_chunks_len_format="H",
seed_len_format="H",
degree_len_format="H")
assert decoder.is_decoded() and decoder.getSolvedCount(
) == encoder.number_of_chunks
os.remove(file)
decoder.saveDecodedFile(print_to_output=False)
if not use_header:
out_file = "DEC_LT_" + file
else:
out_file = file
assert os.path.exists(out_file) and filecmp.cmp(out_file, cmp_file)
if decoder_instance == LTBPDecoder:
# since ApproxDecoder defines an upper bound Gauss-Decoder MUST be able to decode!
decoder = LTDecoder(out_dir,
use_headerchunk=use_header,
dist=dist,
implicit_mode=implicit_mode)
decoder.decodeFolder(number_of_chunks_len_format="H",
seed_len_format="H",
degree_len_format="H")
assert (decoder.is_decoded()
and decoder.getSolvedCount() == encoder.number_of_chunks)
os.remove(out_file)
decoder.saveDecodedFile(print_to_output=False)
assert os.path.exists(out_file) and filecmp.cmp(out_file, cmp_file)
shutil.rmtree(out_dir)