PyCriCodecsEx 0.0.2__cp311-cp311-win32.whl → 0.0.5__cp311-cp311-win32.whl

PyCriCodecsEx/__init__.py

@@ -1 +1 @@
-__version__ = "0.0.2"
+__version__ = "0.0.5"

PyCriCodecsEx/acb.py

@@ -3,22 +3,27 @@
 # - Original work by https://github.com/Youjose/PyCriCodecs
 # See Research/ACBSchema.py for more details.
 
-from typing import Generator, List, Tuple
+from typing import Generator, List, Tuple, BinaryIO
 from PyCriCodecsEx.chunk import *
 from PyCriCodecsEx.utf import UTF, UTFBuilder, UTFViewer
-from PyCriCodecsEx.usm import HCACodec, ADXCodec
+from PyCriCodecsEx.hca import HCACodec
+from PyCriCodecsEx.adx import ADXCodec
 from PyCriCodecsEx.awb import AWB, AWBBuilder
 from dataclasses import dataclass
 from copy import deepcopy
 
 class CueNameTable(UTFViewer):
     CueIndex: int
+    '''Index into CueTable'''
     CueName: str
+    '''Name of the cue'''
 
 
 class CueTable(UTFViewer):
     CueId: int
+    '''Corresponds to the cue index found in CueNameTable'''
     Length: int
+    '''Duration of the cue in milliseconds'''
     ReferenceIndex: int
     ReferenceType: int
 
@@ -51,14 +56,21 @@ class WaveformTable(UTFViewer):
 
 
 class ACBTable(UTFViewer):
+    '''ACB Table View'''
+
     AcbGuid: bytes
+    '''GUID of the ACB. This SHOULD be different for each ACB file.'''
     Name: str
-    Version: int
+    '''Name of the ACB. This is usually the name of the sound bank.'''
+    Version: int    
     VersionString: str
 
     AwbFile: bytes
     CueNameTable: List[CueNameTable]
+    '''A list of cue names with their corresponding indices into CueTable'''
     CueTable: List[CueTable]
+    '''A list of cues with their corresponding references'''
+
     SequenceTable: List[SequenceTable]
     SynthTable: List[SynthTable]
     TrackEventTable: List[TrackEventTable]
@@ -66,7 +78,7 @@ class ACBTable(UTFViewer):
     WaveformTable: List[WaveformTable]
 
     @staticmethod
-    def decode_tlv(data : bytes):
+    def _decode_tlv(data : bytes):
         pos = 0
         while pos < len(data):
             tag = data[pos : pos + 2]
@@ -75,16 +87,16 @@ class ACBTable(UTFViewer):
             pos += 3 + length
             yield (tag, value)
 
-    def waveform_of_track(self, index: int):
-        tlv = self.decode_tlv(self.TrackEventTable[index])
+    def _waveform_of_track(self, index: int):
+        tlv = self._decode_tlv(self.TrackEventTable[index])
         def noteOn(data: bytes):
             # Handle note on event
             tlv_type, tlv_index = AcbTrackCommandNoteOnStruct.unpack(data[:AcbTrackCommandNoteOnStruct.size])
             match tlv_type:
                 case 0x02: # Synth
-                    yield from self.waveform_of_synth(tlv_index)
+                    yield from self._waveform_of_synth(tlv_index)
                 case 0x03: # Sequence
-                    yield from self.waveform_of_sequence(tlv_index)
+                    yield from self._waveform_of_sequence(tlv_index)
                 # Ignore others silently                
         for code, data in tlv:
             match code:
@@ -93,13 +105,13 @@ class ACBTable(UTFViewer):
                 case 2003:
                     yield from noteOn(data)            
 
-    def waveform_of_sequence(self, index : int):
+    def _waveform_of_sequence(self, index : int):
         seq = self.SequenceTable[index]
         for i in range(seq.NumTracks):
             track_index = int.from_bytes(seq.TrackIndex[i*2:i*2+2], 'big')
             yield self.WaveformTable[track_index]
 
-    def waveform_of_synth(self, index: int):        
+    def _waveform_of_synth(self, index: int):        
         item_type, item_index = AcbSynthReferenceStruct.unpack(self.SynthTable[index].ReferenceItems)
         match item_type:
             case 0x00: # No audio
@@ -107,38 +119,52 @@ class ACBTable(UTFViewer):
             case 0x01: # Waveform
                 yield self.WaveformTable[item_index]
             case 0x02: # Yet another synth...
-                yield from self.waveform_of_synth(item_index)
+                yield from self._waveform_of_synth(item_index)
             case 0x03: # Sequence
-                yield from self.waveform_of_sequence(item_index)
+                yield from self._waveform_of_sequence(item_index)
             case _:
                 raise NotImplementedError(f"Unknown synth reference type: {item_type} at index {index}")
 
     def waveform_of(self, index : int) -> List["WaveformTable"]:
+        """Retrieves the waveform(s) associated with a cue.
+
+        Cues may reference multiple waveforms, which could also be reused."""
         cue = next(filter(lambda c: c.CueId == index, self.CueTable), None)
         assert cue, "cue of index %d not found" % index
         match cue.ReferenceType:
             case 0x01:
                 return [self.WaveformTable[index]]
             case 0x02:
-                return list(self.waveform_of_synth(index))
+                return list(self._waveform_of_synth(index))
             case 0x03:
-                return list(self.waveform_of_sequence(index))
+                return list(self._waveform_of_sequence(index))
             case 0x08:
                 raise NotImplementedError("BlockSequence type not implemented yet")
             case _:
                 raise NotImplementedError(f"Unknown cue reference type: {cue.ReferenceType}")
 
 @dataclass(frozen=True)
-class CueItem:
+class PackedCueItem:
+    '''Helper class for read-only cue information'''
+
     CueId: int
+    '''Cue ID'''
     CueName: str
+    '''Cue name'''
     Length: float
-    Waveforms: list[int] # List of waveform IDs
+    '''Duration in seconds'''
+    Waveforms: list[int]
+    '''List of waveform IDs, corresponds to ACB.get_waveforms()'''
 
 class ACB(UTF):
-    """An ACB is basically a giant @UTF table. Use this class to extract any ACB, and potentially modifiy it in place."""
-    def __init__(self, filename) -> None:
-        super().__init__(filename,recursive=True)
+    """Use this class to read, and modify ACB files in memory."""
+    def __init__(self, stream : str | BinaryIO) -> None:
+        """Loads an ACB file from the given stream.
+
+        Args:
+            stream (str | BinaryIO): The path to the ACB file or a BinaryIO stream containing the ACB data.
+        """
+        super().__init__(stream, recursive=True)
 
     @property
     def payload(self) -> dict:
@@ -162,10 +188,17 @@ class ACB(UTF):
         """Returns the AWB object associated with the ACB."""
         return AWB(self.view.AwbFile)
 
-    def get_waveforms(self) -> List[HCACodec | ADXCodec | Tuple[AcbEncodeTypes, int, int, int,  bytes]]:
+    def get_waveforms(self, **kwargs) -> List[HCACodec | ADXCodec | Tuple[AcbEncodeTypes, int, int, int,  bytes]]:
         """Returns a list of decoded waveforms.
 
         Item may be a codec (if known), or a tuple of (Codec ID, Channel Count, Sample Count, Sample Rate, Raw data).
+
+        Additional keyword arguments are passed to the codec constructors. e.g. for encrypted HCA payloads,
+        you may do the following:
+        ```python
+        get_waveforms(key=..., subkey=...)
+        ```
+        See also the respective docs (ADXCodec, HCACodec) for more details.
         """
         CODEC_TABLE = {
             AcbEncodeTypes.ADX: ADXCodec,
@@ -178,7 +211,7 @@ class ACB(UTF):
             encode = AcbEncodeTypes(wav.EncodeType)
             codec = (CODEC_TABLE.get(encode, None))
             if codec:
-                wavs.append(codec(awb.get_file_at(wav.MemoryAwbId)))
+                wavs.append(codec(awb.get_file_at(wav.MemoryAwbId), **kwargs))
             else:
                 wavs.append((encode, wav.NumChannels, wav.NumSamples, wav.SamplingRate, awb.get_file_at(wav.MemoryAwbId)))
         return wavs
@@ -188,7 +221,7 @@ class ACB(UTF):
 
         Input item may be a codec (if known), or a tuple of (Codec ID, Channel Count, Sample Count, Sample Rate, Raw data).
 
-        NOTE: Cue duration is not set. You need to change that manually.
+        NOTE: Cue duration is not set. You need to change that manually - this is usually unecessary as the player will just play until the end of the waveform.
         """
         WAVEFORM = self.view.WaveformTable[0]._payload.copy()
         encoded = []
@@ -228,7 +261,7 @@ class ACB(UTF):
         pass
 
     @property
-    def cues(self) -> Generator[CueItem, None, None]:
+    def cues(self) -> Generator[PackedCueItem, None, None]:
         """Returns a generator of **read-only** Cues.
 
         Cues reference waveform bytes by their AWB IDs, which can be accessed via `waveforms`.
@@ -236,20 +269,25 @@ class ACB(UTF):
         """
         for name, cue in zip(self.view.CueNameTable, self.view.CueTable):
             waveforms = self.view.waveform_of(cue.CueId)
-            yield CueItem(cue.CueId, name.CueName, cue.Length / 1000.0, [waveform.MemoryAwbId for waveform in waveforms])
+            yield PackedCueItem(cue.CueId, name.CueName, cue.Length / 1000.0, [waveform.MemoryAwbId for waveform in waveforms])
 
 class ACBBuilder:
+    """Use this class to build ACB files from an existing ACB object."""
     acb: ACB
 
     def __init__(self, acb: ACB) -> None:
         """Initializes the ACBBuilder with an existing ACB object.
         
+        Args:
+            acb (ACB): The ACB object to build from.
+
         Building ACB from scratch isn't planned for now since:
-        * We don't know how SeqCommandTable TLVs work. This is the biggest issue.
-        * Many fields are unknown or not well understood
-          - Games may expect AcfReferenceTable, Asiac stuff etc to be present for their own assets in conjunction
-            with their own ACF table. Missing these is not a fun debugging experience.
-        * ACB tables differ a LOT from game to game (e.g. Lipsync info), contary to USM formats.
+                
+            * We don't know how SeqCommandTable TLVs work. This is the biggest issue.
+            * Many fields are unknown or not well understood
+            - Games may expect AcfReferenceTable, Asiac stuff etc to be present for their own assets in conjunction
+                with their own ACF table. Missing these is not a fun debugging experience.
+            * ACB tables differ a LOT from game to game (e.g. Lipsync info), contary to USM formats.
 
         Maybe one day I'll get around to this. But otherwise starting from nothing is a WONTFIX for now.
         """

PyCriCodecsEx/adx.py

@@ -1,8 +1,13 @@
+from typing import BinaryIO
+from io import BytesIO
+from PyCriCodecsEx.chunk import *
 import CriCodecsEx
-
 class ADX:
-    """ADX Module for decoding and encoding ADX files, pass the either `adx file` or `wav file` in bytes to either `decode` or `encode` respectively."""  
-    
+    """ADX class for decoding and encoding ADX files, pass the either `adx file` or `wav file` in bytes to either `decode` or `encode` respectively.
+
+    **NOTE:** Direct usage of this class is not recommended, use the `ADXCodec` wrapper instead.
+    """
+
     # Decodes ADX to WAV.
     @staticmethod
     def decode(data: bytes) -> bytes:
@@ -13,4 +18,141 @@ class ADX:
     @staticmethod
     def encode(data: bytes, BitDepth = 0x4, Blocksize = 0x12, Encoding = 3, AdxVersion = 0x4, Highpass_Frequency = 0x1F4, Filter = 0, force_not_looping = False) -> bytes:
         """ Encodes WAV to ADX. """
-        return CriCodecsEx.AdxEncode(bytes(data), BitDepth, Blocksize, Encoding, Highpass_Frequency, Filter, AdxVersion, force_not_looping)
+        return CriCodecsEx.AdxEncode(bytes(data), BitDepth, Blocksize, Encoding, Highpass_Frequency, Filter, AdxVersion, force_not_looping)
+    
+class ADXCodec(ADX):
+    """Use this class for encoding and decoding ADX files, from and to WAV."""
+
+    CHUNK_INTERVAL = 99.9
+    BASE_FRAMERATE = 2997
+    # TODO: Move these to an enum
+    AUDIO_CODEC = 2
+    METADATA_COUNT = 0
+
+    filename : str
+    filesize : int
+
+    adx : bytes
+    header : bytes
+    sfaStream: BinaryIO    
+
+    AdxDataOffset: int
+    AdxEncoding: int
+    AdxBlocksize: int
+    AdxSampleBitdepth: int
+    AdxChannelCount: int
+    AdxSamplingRate: int
+    AdxSampleCount: int
+    AdxHighpassFrequency: int
+    AdxVersion: int
+    AdxFlags: int
+
+    chnls: int
+    sampling_rate: int
+    total_samples: int
+    avbps: int
+
+    def __init__(self, stream: str | bytes, filename: str = "default.adx", bitdepth: int = 4, **kwargs):
+        """Initializes the ADX encoder/decoder
+
+        Args:
+            stream (str | bytes): Path to the ADX or WAV file, or a BinaryIO stream. WAV files will be automatically encoded with the given settings first.
+            filename (str, optional): Filename, used by USMBuilder. Defaults to "default.adx".
+            bitdepth (int, optional): Audio bit depth within [2,15]. Defaults to 4.
+        """
+        if type(stream) == str:
+            self.adx = open(stream, "rb").read()
+        else:
+            self.adx = stream
+        self.filename = filename
+        self.filesize = len(self.adx)
+        magic = self.adx[:4]
+        if magic == b"RIFF":
+            self.adx = self.encode(self.adx, bitdepth, force_not_looping=True)        
+        self.sfaStream = BytesIO(self.adx)
+        header = AdxHeaderStruct.unpack(self.sfaStream.read(AdxHeaderStruct.size))
+        FourCC, self.AdxDataOffset, self.AdxEncoding, self.AdxBlocksize, self.AdxSampleBitdepth, self.AdxChannelCount, self.AdxSamplingRate, self.AdxSampleCount, self.AdxHighpassFrequency, self.AdxVersion, self.AdxFlags = header
+        assert FourCC == 0x8000, "either ADX or WAV is supported"
+        assert self.AdxVersion in {3,4}, "unsupported ADX version"
+        if self.AdxVersion == 4:
+            self.sfaStream.seek(4 + 4  * self.AdxChannelCount, 1)  # Padding + Hist values, they always seem to be 0.
+        self.sfaStream.seek(0)
+        self.chnls = self.AdxChannelCount
+        self.sampling_rate = self.AdxSamplingRate
+        self.total_samples = self.AdxSampleCount
+        self.avbps = int(self.filesize * 8 * self.chnls) - self.filesize
+    
+    def generate_SFA(self, index: int, builder):
+        # USMBuilder usage
+        current_interval = 0
+        stream_size = len(self.adx) - self.AdxBlocksize
+        chunk_size = int(self.AdxSamplingRate // (self.BASE_FRAMERATE / 100) // 32) * (self.AdxBlocksize * self.AdxChannelCount)
+        self.sfaStream.seek(0)
+        res = []
+        while self.sfaStream.tell() < stream_size:
+            if self.sfaStream.tell() > 0:
+                if self.sfaStream.tell() + chunk_size < stream_size:
+                    datalen = chunk_size
+                else:
+                    datalen = (stream_size - (self.AdxDataOffset + 4) - chunk_size) % chunk_size
+            else:
+                datalen = self.AdxDataOffset + 4
+            if not datalen:
+                break
+            padding = (0x20 - (datalen % 0x20) if datalen % 0x20 != 0 else 0)
+            SFA_chunk = USMChunkHeader.pack(
+                    USMChunckHeaderType.SFA.value,
+                    datalen + 0x18 + padding,
+                    0,
+                    0x18,
+                    padding,
+                    index,
+                    0,
+                    0,
+                    0,
+                    round(current_interval),
+                    self.BASE_FRAMERATE,
+                    0,
+                    0
+                    )
+            chunk_data = self.sfaStream.read(datalen)
+            if builder.encrypt_audio:
+                SFA_chunk = builder.AudioMask(chunk_data)
+            SFA_chunk += chunk_data.ljust(datalen + padding, b"\x00")            
+            current_interval += self.CHUNK_INTERVAL
+            res.append(SFA_chunk)
+        # ---
+        SFA_chunk = USMChunkHeader.pack(
+                    USMChunckHeaderType.SFA.value,
+                    0x38,
+                    0,
+                    0x18,
+                    0,
+                    index,
+                    0,
+                    0,
+                    2,
+                    0,
+                    30,
+                    0,
+                    0
+                    )
+        SFA_chunk += b"#CONTENTS END   ===============\x00"
+        res[-1] += SFA_chunk
+        return res
+
+    def get_metadata(self):
+        return None
+
+    def get_encoded(self) -> bytes:
+        """Gets the encoded ADX audio data."""
+        return self.adx
+
+    def save(self, filepath: str | BinaryIO):
+        """Saves the decoded WAV audio to filepath or a writable stream"""
+        if type(filepath) == str:
+            with open(filepath, "wb") as f:
+                f.write(self.decode(self.adx))
+        else:
+            filepath.write(self.decode(self.adx))
+

PyCriCodecsEx/awb.py

@@ -1,6 +1,5 @@
 from io import BytesIO, FileIO
-import os
-from typing import BinaryIO
+from typing import BinaryIO, Generator
 from struct import iter_unpack, pack
 from PyCriCodecsEx.chunk import *
 from PyCriCodecsEx.hca import HCA
@@ -55,7 +54,7 @@ class AWB:
             self.headersize = self.headersize + (self.align - (self.headersize % self.align))
         self.stream.seek(self.headersize, 0)
 
-    def get_files(self):
+    def get_files(self) -> Generator[bytes, None, None]:
         """Generator function to yield all data blobs from an AWB. """
         self.stream.seek(self.headersize, 0)
         for i in range(1, len(self.ofs)):
@@ -82,6 +81,7 @@ class AWB:
             raise ValueError("Unknown int size.")
 
 class AWBBuilder:
+    """Use this class to build AWB files from a list of bytes."""
     def __init__(self, infiles: list[bytes], subkey: int = 0, version: int = 2, id_intsize = 0x2, align: int = 0x20) -> None:
         """Initializes the AWB builder.
 

PyCriCodecsEx/chunk.py

@@ -46,11 +46,6 @@ class HCAType(Enum):
     HCA   = b"HCA\x00" # Header.
     EHCA  = b"\xC8\xC3\xC1\x00" # Encrypted HCA header.
 
-class VideoType(Enum):
-    IVF   = b"DKIF" # Header.
-    # H264  = b"" # Header.
-    # MPEG  = b"" # Header.
-
 # I saw some devs swap the unsigned/signed indexes. So I am not sure what's correct or not.
 # In my own experience, swapping those results in an incorrect signed values (should be unsigned) in ACB's/CPK's.
 # If someone were to change this, they must change 'stringtypes' function in UTF/UTFBuilder classes.

PyCriCodecsEx/cpk.py

@@ -1,20 +1,27 @@
 import os
-from typing import BinaryIO
+from typing import BinaryIO, Generator
 from io import BytesIO, FileIO
 from PyCriCodecsEx.chunk import *
 from PyCriCodecsEx.utf import UTF, UTFBuilder
 from dataclasses import dataclass
-from concurrent.futures import ProcessPoolExecutor, as_completed
+from concurrent.futures import ThreadPoolExecutor, as_completed
 from tempfile import NamedTemporaryFile
 import CriCodecsEx
 
-def _worker_do_compression(src : str, dst: str):
+def _crilayla_compress_to_file(src : str, dst: str):
     with open(src, "rb") as fsrc, open(dst, "wb") as fdst:
         data = fsrc.read()
-        compressed = CriCodecsEx.CriLaylaCompress(data)
-        fdst.write(compressed)
+        try:
+            compressed = CriCodecsEx.CriLaylaCompress(data)
+            fdst.write(compressed)
+        except:
+            # Fallback for failed compression
+            # Again. FIXME.
+            fdst.write(data)
+            
 @dataclass
-class _PackFile():
+class PackedFile():
+    """Helper class for packed files within a CPK."""
     stream: BinaryIO
     path: str
     offset: int   
@@ -22,6 +29,7 @@ class _PackFile():
     compressed : bool = False
 
     def get_bytes(self) -> bytes:
+        """Get the raw bytes of the packed file, decompressing if necessary."""
         self.stream.seek(self.offset)
         data = self.stream.read(self.size)
         if self.compressed:
@@ -29,6 +37,7 @@ class _PackFile():
         return data
 
     def save(self, path : str):
+        """Save the packed file to a specified path."""
         with open(path, "wb") as f:
             f.write(self.get_bytes())
 class _TOC():
@@ -48,6 +57,7 @@ class _TOC():
         self.table = UTF(self.stream.read()).table
 
 class CPK:
+    """Use this class to load CPK file table-of-content, and read files from them on-demand."""
     magic: bytes
     encflag: int
     packet_size: int
@@ -114,6 +124,9 @@ class CPK:
     
     @property
     def mode(self):
+        """Get the current mode of the CPK archive. [0,1,2,3]
+        
+        See also CPKBuilder"""
         TOC, ITOC, GTOC = 'TOC' in self.tables, 'ITOC' in self.tables, 'GTOC' in self.tables
         if TOC and ITOC and GTOC:
             return 3
@@ -126,8 +139,8 @@ class CPK:
         raise ValueError("Unknown CPK mode.")
 
     @property
-    def files(self):
-        """Retrieves a list of all files in the CPK archive."""
+    def files(self) -> Generator[PackedFile, None, None]:
+        """Creates a generator for all files in the CPK archive as PackedFile."""
         if "TOC" in self.tables:
             toctable = self.tables['TOC']
             rel_off = 0x800
@@ -138,10 +151,10 @@ class CPK:
                     filename = filename[:250] + "_" + str(i) # 250 because i might be 4 digits long.
                 if toctable['ExtractSize'][i] > toctable['FileSize'][i]:
                     self.stream.seek(rel_off+toctable["FileOffset"][i], 0)
-                    yield _PackFile(self.stream, os.path.join(dirname,filename), self.stream.tell(), toctable['FileSize'][i], compressed=True)
+                    yield PackedFile(self.stream, os.path.join(dirname,filename), self.stream.tell(), toctable['FileSize'][i], compressed=True)
                 else:
                     self.stream.seek(rel_off+toctable["FileOffset"][i], 0)
-                    yield _PackFile(self.stream, os.path.join(dirname,filename), self.stream.tell(), toctable['FileSize'][i])                    
+                    yield PackedFile(self.stream, os.path.join(dirname,filename), self.stream.tell(), toctable['FileSize'][i])                    
         elif "ITOC" in self.tables:
             toctableL = self.tables["ITOC"]['DataL'][0]
             toctableH = self.tables["ITOC"]['DataH'][0]
@@ -153,18 +166,18 @@ class CPK:
                 if i in toctableH['ID']:
                     idx = toctableH['ID'].index(i)
                     if toctableH['ExtractSize'][idx] > toctableH['FileSize'][idx]:
-                        yield _PackFile(self.stream, str(i), self.stream.tell(), toctableH['FileSize'][idx], compressed=True)
+                        yield PackedFile(self.stream, str(i), self.stream.tell(), toctableH['FileSize'][idx], compressed=True)
                     else:
-                        yield _PackFile(self.stream, str(i), self.stream.tell(), toctableH['FileSize'][idx])
+                        yield PackedFile(self.stream, str(i), self.stream.tell(), toctableH['FileSize'][idx])
                     if toctableH['FileSize'][idx] % align != 0:
                         seek_size = (align - toctableH['FileSize'][idx] % align)
                         self.stream.seek(seek_size, 1)
                 elif i in toctableL['ID']:
                     idx = toctableL['ID'].index(i)
                     if toctableL['ExtractSize'][idx] > toctableL['FileSize'][idx]:
-                        yield _PackFile(self.stream, str(i), self.stream.tell(), toctableL['FileSize'][idx], compressed=True)
+                        yield PackedFile(self.stream, str(i), self.stream.tell(), toctableL['FileSize'][idx], compressed=True)
                     else:
-                        yield _PackFile(self.stream, str(i), self.stream.tell(), toctableL['FileSize'][idx])
+                        yield PackedFile(self.stream, str(i), self.stream.tell(), toctableL['FileSize'][idx])
                     if toctableL['FileSize'][idx] % align != 0:
                         seek_size = (align - toctableL['FileSize'][idx] % align)
                         self.stream.seek(seek_size, 1)
@@ -189,7 +202,7 @@ class CPKBuilder:
     ContentSize: int
     EnabledDataSize: int
     EnabledPackedSize: int
-    outfile: str
+    outfile: BinaryIO
     init_toc_len: int # This is a bit of a redundancy, but some CPK's need it.
 
     in_files : list[tuple[str, str, bool]] # (source path, dest filename, compress or not)
@@ -246,24 +259,22 @@ class CPKBuilder:
             compress (bool, optional): Whether to compress the file. Defaults to False.
         
         NOTE: 
-            - In ITOC-related mode, the insertion order determines the final integer ID of the files.
-            - Compression can be VERY slow with high entropy files (e.g. encoded media). Use at discretion.
-        """
+            - In ITOC-related mode, the insertion order determines the final integer ID of the files.            
+        """        
         if not dst and self.mode != 0:
             raise ValueError("Destination filename must be specified in non-ITOC mode.")
         
         self.in_files.append((src, dst, compress))
 
-    def _writetofile(self, header) -> None:
-        with open(self.outfile, "wb") as out:
-            out.write(header)
-            for i, ((path, _), (filename, file_size, pack_size)) in enumerate(zip(self.os_files, self.files)):
-                src = open(path, 'rb').read()
-                out.write(src)
-                out.write(bytes(0x800 - pack_size % 0x800))
-                self.progress_cb("Write %s" % os.path.basename(filename), i + 1, len(self.files))
+    def _writetofile(self, header) -> None:        
+        self.outfile.write(header)
+        for i, ((path, _), (filename, file_size, pack_size)) in enumerate(zip(self.os_files, self.files)):
+            src = open(path, 'rb').read()
+            self.outfile.write(src)
+            self.outfile.write(bytes(0x800 - pack_size % 0x800))
+            self.progress_cb("Write %s" % os.path.basename(filename), i + 1, len(self.files))
 
-    def _populate_files(self, parallel : bool):
+    def _populate_files(self, threads : int = 1):
         self.files = []
         for src, dst, compress in self.in_files:
             if compress:
@@ -271,23 +282,15 @@ class CPKBuilder:
                 self.os_files.append((tmp.name, True))
             else:
                 self.os_files.append((src, False))
-        if parallel:
-            with ProcessPoolExecutor() as exec:
-                futures = []
-                for (src, _, _), (dst, compress) in zip(self.in_files,self.os_files):
-                    if compress:
-                        futures.append(exec.submit(_worker_do_compression, src, dst))
-                for i, fut in as_completed(futures):
-                    try:
-                        fut.result()
-                    except:
-                        pass
-                    self.progress_cb("Compress %s" % os.path.basename(src), i + 1, len(futures))
-        else:
-            for i, ((src, _, _), (dst, compress)) in enumerate(zip(self.in_files,self.os_files)):
-                    if compress:
-                        _worker_do_compression(src, dst)
-                        self.progress_cb("Compress %s" % os.path.basename(src), i + 1, len(self.in_files))
+        with ThreadPoolExecutor(max_workers=threads) as exec:
+            futures = []
+            for (src, _, _), (dst, compress) in zip(self.in_files,self.os_files):
+                if compress:
+                    _crilayla_compress_to_file(src, dst)
+                    # futures.append(exec.submit(_crilayla_compress_to_file, src, dst))
+            for i, fut in enumerate(as_completed(futures)):
+                fut.result()
+                self.progress_cb("Compress %s" % os.path.basename(src), i + 1, len(futures))
         for (src, filename, _) , (dst, _) in zip(self.in_files,self.os_files):
             file_size = os.stat(src).st_size         
             pack_size = os.stat(dst).st_size
@@ -304,21 +307,22 @@ class CPKBuilder:
                 pass
         self.os_files = []
 
-    def save(self, outfile : str, parallel : bool = False):
+    def save(self, outfile : str | BinaryIO, threads : int = 1):
         """Build and save the bundle into a file
 
 
         Args:
-            outfile (str): The output file path.
-            parallel (bool, optional): Whether to use parallel processing for file compression (if at all used). Defaults to False.
+            outfile (str | BinaryIO): The output file path or a writable binary stream.
+            threads (int, optional): The number of threads to use for file compression. Defaults to 1.
 
         NOTE: 
             - Temporary files may be created during the process if compression is used.
-            - parallel uses multiprocessing. Make sure your main function is guarded with `if __name__ == '__main__'` clause.
         """
         assert self.in_files, "cannot save empty bundle"
         self.outfile = outfile
-        self._populate_files(parallel)
+        if type(outfile) == str:
+            self.outfile = open(outfile, "wb")
+        self._populate_files(threads)
         if self.encrypt:
             encflag = 0
         else:
@@ -363,7 +367,9 @@ class CPKBuilder:
             data = self.CPKdata.ljust(len(self.CPKdata) + (0x800 - len(self.CPKdata) % 0x800) - 6, b'\x00') + bytearray(b"(c)CRI") + self.ITOCdata
         self._writetofile(data)
         self._cleanup_files()
-    
+        if type(outfile) == str:
+            self.outfile.close()
+            
     def _generate_GTOC(self) -> bytearray:
         # NOTE: Practically useless
         # I have no idea why are those numbers here.