PyCriCodecsEx 0.0.1__cp313-cp313-win32.whl

PyCriCodecsEx/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.0.1"

PyCriCodecsEx/acb.py

@@ -0,0 +1,100 @@
+from struct import iter_unpack
+from typing import BinaryIO, List
+from io import BytesIO
+from PyCriCodecsEx.chunk import *
+from PyCriCodecsEx.utf import UTF, UTFBuilder, UTFViewer
+from PyCriCodecsEx.awb import AWB, AWBBuilder
+from PyCriCodecsEx.hca import HCA
+from copy import deepcopy
+import os
+
+# Credit:
+# - github.com/vgmstream/vgmstream which is why this is possible at all
+# - Original work by https://github.com/Youjose/PyCriCodecs
+# See Research/ACBSchema.py for more details.
+
+class CueNameTable(UTFViewer):
+    CueIndex: int
+    CueName: str
+
+
+class CueTable(UTFViewer):
+    CueId: int
+    ReferenceIndex: int
+    ReferenceType: int
+
+
+class SequenceTable(UTFViewer):
+    TrackIndex: bytes
+    Type: int
+
+
+class SynthTable(UTFViewer):
+    ReferenceItems: bytes
+
+
+class TrackEventTable(UTFViewer):
+    Command: bytes
+
+
+class TrackTable(UTFViewer):
+    EventIndex: int
+
+
+class WaveformTable(UTFViewer):
+    EncodeType: int
+    MemoryAwbId: int
+    NumChannels: int
+    NumSamples: int
+    SamplingRate: int
+    Streaming: int
+
+
+class ACBTable(UTFViewer):
+    AcbGuid: bytes
+    Name: str
+    Version: int
+    VersionString: str
+
+    AwbFile: bytes
+    CueNameTable: List[CueNameTable]
+    CueTable: List[CueTable]
+    SequenceTable: List[SequenceTable]
+    SynthTable: List[SynthTable]
+    TrackEventTable: List[TrackEventTable]
+    TrackTable: List[TrackTable]
+    WaveformTable: List[WaveformTable]
+
+
+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)
+
+    @property
+    def payload(self) -> dict:
+        """Retrives the only top-level UTF table dict within the ACB file."""
+        return self.dictarray[0]
+
+    @property
+    def view(self) -> ACBTable:
+        """Returns a view of the ACB file, with all known tables mapped to their respective classes."""
+        return ACBTable(self.payload)
+
+    # TODO: Extraction routines
+    # See Research/ACBSchema.py. vgmstream presented 4 possible permutations of subsong retrieval.
+
+class ACBBuilder:
+    acb: ACB
+
+    def __init__(self, acb: ACB) -> None:
+        self.acb = acb
+
+    def build(self) -> bytes:
+        """Builds an ACB binary blob from the current ACB object.
+
+        The object may be modified in place before building, which will be reflected in the output binary.
+        """
+        payload = deepcopy(self.acb.dictarray)
+        binary = UTFBuilder(payload, encoding=self.acb.encoding, table_name=self.acb.table_name)
+        return binary.bytes()

PyCriCodecsEx/adx.py

@@ -0,0 +1,16 @@
+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."""  
+    
+    # Decodes ADX to WAV.
+    @staticmethod
+    def decode(data: bytes) -> bytes:
+        """ Decodes ADX to WAV. """
+        return CriCodecsEx.AdxDecode(bytes(data))
+            
+    # Encodes WAV to 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)

PyCriCodecsEx/awb.py

@@ -0,0 +1,151 @@
+from io import BytesIO, FileIO
+import os
+from typing import BinaryIO
+from struct import iter_unpack, pack
+from PyCriCodecsEx.chunk import *
+from PyCriCodecsEx.hca import HCA
+
+# for AFS2 only.
+class AWB:
+    """ Use this class to return any AWB data with the getfiles function. """    
+    stream: BinaryIO
+    numfiles: int
+    align: int
+    subkey: bytes
+    version: int
+    ids: list
+    ofs: list
+    filename: str
+    headersize: int
+    id_alignment: int
+
+    def __init__(self, stream) -> None:
+        if type(stream) == str:
+            self.stream = FileIO(stream)
+            self.filename = stream
+        else:
+            self.stream = BytesIO(stream)
+            self.filename = ""
+        self.readheader()
+    
+    def readheader(self):
+        # Reads header.
+        magic, self.version, offset_intsize, self.id_intsize, self.numfiles, self.align, self.subkey = AWBChunkHeader.unpack(
+            self.stream.read(AWBChunkHeader.size)
+        )
+        if magic != b'AFS2':
+            raise ValueError("Invalid AWB header.")
+        
+        # Reads data in the header.
+        self.ids = list()
+        self.ofs = list()
+        for i in iter_unpack(f"<{self.stringtypes(self.id_intsize)}", self.stream.read(self.id_intsize*self.numfiles)):
+            self.ids.append(i[0])
+        for i in iter_unpack(f"<{self.stringtypes(offset_intsize)}", self.stream.read(offset_intsize*(self.numfiles+1))):
+            self.ofs.append(i[0] if i[0] % self.align == 0 else (i[0] + (self.align - (i[0] % self.align))))
+        
+        # Seeks to files offset.
+        self.headersize = 16 + (offset_intsize*(self.numfiles+1)) + (self.id_intsize*self.numfiles)
+        if self.headersize % self.align != 0:
+            self.headersize = self.headersize + (self.align - (self.headersize % self.align))
+        self.stream.seek(self.headersize, 0)
+
+    def get_files(self):
+        """ Generator function to yield all data blobs from an AWB. """
+        for i in range(1, len(self.ofs)):
+            data = self.stream.read((self.ofs[i]-self.ofs[i-1]))
+            self.stream.seek(self.ofs[i], 0)
+            yield data
+    
+    def get_file_at(self, index):
+        """ Gets you a file at specific index. """
+        index += 1
+        self.stream.seek(self.ofs[index], 0)
+        data = self.stream.read(self.ofs[index]-self.ofs[index-1])
+        self.stream.seek(self.headersize, 0) # Seeks back to headersize for getfiles.
+        return data
+
+    def stringtypes(self, intsize: int) -> str:
+        if intsize == 1:
+            return "B" # Probably impossible.
+        elif intsize == 2:
+            return "H"
+        elif intsize == 4:
+            return "I"
+        elif intsize == 8:
+            return "Q"
+        else:
+            raise ValueError("Unknown int size.")
+
+class AWBBuilder:
+    def __init__(self, infiles: list[bytes], subkey: int = 0, version: int = 2, id_intsize = 0x2, align: int = 0x20) -> None:
+        if version == 1 and subkey != 0:
+            raise ValueError("Cannot have a subkey with AWB version of 1.")
+        elif id_intsize not in [0x2, 0x4, 0x8]:
+            raise ValueError("id_intsize must be either 2, 4 or 8.")
+        self.infiles = infiles
+        self.version = version
+        self.align = align
+        self.subkey = subkey
+        self.id_intsize = id_intsize
+        
+    def stringtypes(self, intsize: int) -> str:
+        if intsize == 1:
+            return "B" # Probably impossible.
+        elif intsize == 2:
+            return "H"
+        elif intsize == 4:
+            return "I"
+        elif intsize == 8:
+            return "Q"
+        else:
+            raise ValueError("Unknown int size.")
+
+    def build(self) -> bytes:
+        size = 0
+        ofs = []
+        numfiles = 0
+        for file in self.infiles:
+            sz = len(file)
+            ofs.append(size+sz)
+            size += sz
+            numfiles += 1
+        
+        if size > 0xFFFFFFFF:
+            intsize = 8 # Unsigned long long.
+            strtype = "<Q"
+        else:
+            intsize = 4 # Unsigned int, but could be a ushort, never saw it as one before though.
+            strtype = "<I"
+        
+        header = AWBChunkHeader.pack(
+            b'AFS2', self.version, intsize, self.id_intsize, numfiles, self.align, self.subkey
+        )
+
+        id_strsize = f"<{self.stringtypes(self.id_intsize)}"
+        for i in range(numfiles):
+            header += pack(id_strsize, i)
+        
+        headersize = len(header) + intsize * numfiles + intsize
+        aligned_header_size = headersize + (self.align - (headersize % self.align))
+        ofs2 = []
+        for idx, x in enumerate(ofs):
+            if (x+aligned_header_size) % self.align != 0 and idx != len(ofs) - 1:
+                ofs2.append((x+aligned_header_size) + (self.align - ((x+aligned_header_size) % self.align)))
+            else:
+                ofs2.append(x+aligned_header_size)
+        ofs = [headersize] + ofs2
+
+        for i in ofs:
+            header += pack(strtype, i)
+        
+        if headersize % self.align != 0:
+            header = header.ljust(headersize + (self.align - (headersize % self.align)), b"\x00")
+        outfile = BytesIO()
+        outfile.write(header)
+        for idx, file in enumerate(self.infiles):
+            fl = file
+            if len(fl) % self.align != 0 and idx != len(self.infiles) - 1:
+                fl = fl.ljust(len(fl) + (self.align - (len(fl) % self.align)), b"\x00")
+            outfile.write(fl)
+        return outfile.getvalue()

PyCriCodecsEx/chunk.py

@@ -0,0 +1,75 @@
+from struct import Struct
+from enum import Enum
+
+UTFChunkHeader = Struct(">4sIIIIIHHI")
+USMChunkHeader = Struct(">4sIBBHBBBBIIII")
+CPKChunkHeader = Struct("<4sIII")
+AWBChunkHeader = Struct("<4sBBHIHH")
+SBTChunkHeader = Struct("<IIIII")
+WavHeaderStruct = Struct("<4sI4s4sIHHIIHH") # This is wrong, FMT Struct should be on its own, away from RIFF.
+WavSmplHeaderStruct = Struct("<4sIIIIIIIIIIIIIIII") # Supports only 1 looping point.
+WavNoteHeaderStruct = Struct("<4sII")
+WavDataHeaderStruct = Struct("<4sI")
+AdxHeaderStruct = Struct(">HHBBBBIIHBB")
+AdxLoopHeaderStruct = Struct(">HHHHIIII")
+
+class USMChunckHeaderType(Enum):
+    CRID  = b"CRID" # Header.
+    SFSH  = b"SFSH" # SofDec1 Header?
+    SFV   = b"@SFV" # Video (VP9/H264/MPEG).
+    SFA   = b"@SFA" # Audio (HCA/ADX).
+    ALP   = b"@ALP" # Rare. (Alpha video information).
+    CUE   = b"@CUE" # Rare. (Cue points).
+    SBT   = b"@SBT" # Rare. (Subtitle information).
+    AHX   = b"@AHX" # Rare. (Ahx audio file? Used for SofDec1 only?)
+    USR   = b"@USR" # Rare. (User data?)
+    PST   = b"@PST" # Rare. (Unknown).
+
+class CPKChunkHeaderType(Enum):
+    CPK   = b"CPK " # Header.
+    TOC   = b"TOC " # Cpkmode 1, 2, 3.
+    ITOC  = b"ITOC" # Cpkmode 0, 2.
+    GTOC  = b"GTOC" # Cpkmode 3.
+    ETOC  = b"ETOC" # Any CpkMode. Not important.
+    HTOC  = b"HTOC" # Unknown.
+    HGTOC = b"HGTOC"# Unknown.
+
+class UTFType(Enum):
+    UTF   = b"@UTF" # Header.
+    EUTF  = b"\x1F\x9E\xF3\xF5" # Encrypted @UTF Header. Very likely exclusive to CPK's @UTF only.
+
+class AWBType(Enum):
+    AFS2  = b"AFS2" # Header.
+
+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.
+class UTFTypeValues(Enum):
+    uchar  = 0
+    char   = 1
+    ushort = 2
+    short  = 3
+    uint   = 4
+    int    = 5
+    ullong = 6
+    llong  = 7
+    float  = 8
+    double = 9 # Does not seem to exist.
+    string = 10
+    bytes  = 11
+
+class CriHcaQuality(Enum):
+    Highest = 0
+    High    = 1
+    Middle  = 2
+    Low     = 3
+    Lowest  = 5