def search4cave(stream: io.RawIOBase, section_name: str, section_size: int,
section_info, cave_size: int, virtaddr: int, _bytes: bytes):
caves = []
byte_count = 0
base = stream.tell()
offset = 0
while section_size > 0:
rb = stream.read(1)
section_size -= 1
offset += 1
if _bytes not in rb:
if byte_count >= cave_size:
mr = MiningResult()
mr.name = section_name
mr.cave_begin = (base + offset) - byte_count - 1
mr.cave_end = (base + offset) - 1
mr.cave_size = byte_count
mr.virtaddr = virtaddr + offset - byte_count - 1
mr.info = section_info
caves.append(mr)
byte_count = 0
continue
byte_count += 1
stream.seek(base)
return caves
def __init__(self, stream: RawIOBase, chunk_size=4096, *args, **kwargs):
self.chunk_size = chunk_size
# Get content-size
stream.seek(0, os.SEEK_END)
content_length = stream.tell()
stream.seek(0, os.SEEK_SET)
super().__init__(stream, content_len=content_length, *args, **kwargs)
def verifycave(stream: io.RawIOBase, cave_size, _byte: bytes):
base = stream.tell()
success = True
while cave_size > 0:
cave_size -= 1
rb = stream.read(1)
if _byte not in rb:
success = False
break
stream.seek(base)
return success
def statistiques(source: io.RawIOBase) -> (Compteur, int):
"""
Fonction de calcul des statistiques dans le cadre de la compression de Huffman
"""
compteur = Compteur()
source.seek(0)
octet = source.read(1)
iterator = 0
while octet:
compteur.incrementer(octet)
iterator += 1
octet = source.read(1)
return (compteur, iterator)
def cache_segment_data(input_file: io.RawIOBase, segments: List[Any], segment_id: int, base_file_offset: int=0) -> None:
"""
base_file_offset: when the input file is located within a containing file.
"""
data = None
file_offset = get_segment_data_file_offset(segments, segment_id)
# No data for segments that have no data..
if file_offset != -1:
file_length = get_segment_data_length(segments, segment_id)
input_file.seek(base_file_offset + file_offset, os.SEEK_SET)
file_data = bytearray(file_length)
if input_file.readinto(file_data) == file_length:
# NOTE(rmtew): Python 2, type(data[0]) is str. Python 3, type(data[0]) is int
data = memoryview(file_data)
else:
logger.error("Unable to cache segment %d data, got %d bytes, wanted %d", segment_id, len(file_data), file_length)
segments[segment_id][SI_CACHED_DATA] = data
def read_wad(f: io.RawIOBase):
f.seek(0)
header = f.read(256)
if header[:4] != WAD_MAGIC:
raise CommandError(
f'File does not appear to be a Zwift WAD file, Expected '
f'magic: {WAD_MAGIC}, actual: {header[:4]}')
body_size = struct.unpack('<I', header[248:252])[0]
wad_size = 256 + body_size
actual_size = os.fstat(f.fileno()).st_size
if actual_size < wad_size:
raise CommandError(f'Truncated wad file: header implies '
f'{wad_size} bytes but file is {actual_size} bytes')
if actual_size > wad_size:
warnings.warn(
f'wad file is larger than header implies. expected size: '
f'{actual_size} bytes, actual size: {actual_size} bytes')
entry_pointers = read_entry_pointers(f)
return {'file': f, 'entry_pointers': entry_pointers}
def decompresser(destination: io.RawIOBase, source: io.RawIOBase):
"""
Fonction qui permet la décompression selon la méthode de Huffman.
"""
def naturel_to_list(naturel):
"""
Fonction qui permet de passer d'un naturel à une liste de Bit.
"""
liste = []
while naturel != 0:
liste.append(Bit.BIT_0 if naturel%2 == 0 else Bit.BIT_1)
naturel = naturel // 2
if len(liste) < 8:
liste += [Bit.BIT_0 for i in range(8-len(liste))]
liste.reverse()
return liste
def recherche_identifiant():
"""
Fonction qui recherche l'identifiant du flux source.
"""
identifiant = ""
for i in range(4):
identifiant = identifiant + chr(int.from_bytes(source.read(1), sys.byteorder))
return identifiant
def recherche_stats():
"""
Fonction qui recherche les nombres d'occurences des 256 octets dans le flux source.
"""
stat = Compteur()
for i in range(256):
occurence = int.from_bytes(source.read(4), sys.byteorder)
if occurence > 0:
stat.fixer(i.to_bytes(1, sys.byteorder), occurence)
return stat
def reconstruction():
"""
Fonction qui reconstruit le contenu du flux source
avant compression à partir de l'arbre obtenu des statistiques.
"""
octet = source.read(1)
arbre_courant = arbre
longueur_courante = 0
while longueur_courante < longueur and octet:
liste_bits = naturel_to_list(int.from_bytes(octet, sys.byteorder))
for i in liste_bits:
if arbre_courant.est_une_feuille:
destination.write(arbre_courant.element)
arbre_courant = arbre
longueur_courante += 1
if i == Bit.BIT_0:
arbre_courant = arbre_courant.fils_gauche
else:
arbre_courant = arbre_courant.fils_droit
octet = source.read(1)
yield "Décompression"
source.seek(0)
yield "Cas général"
identifiant = recherche_identifiant()
if identifiant == "HUFF":
longueur = int.from_bytes(source.read(4), sys.byteorder)
yield "Lecture des stats"
stat = recherche_stats()
yield "Création de l'arbre de Huffman"
arbre = arbre_de_huffman(stat)
yield "Création du fichier decompressé"
reconstruction()
