PyCriCodecsEx 0.0.5__cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl

PyCriCodecsEx/__init__.py

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

PyCriCodecsEx/acb.py

@@ -0,0 +1,306 @@
+# 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.
+
+from typing import Generator, List, Tuple, BinaryIO
+from PyCriCodecsEx.chunk import *
+from PyCriCodecsEx.utf import UTF, UTFBuilder, UTFViewer
+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
+
+
+class SequenceTable(UTFViewer):
+    NumTracks : int
+    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):
+    '''ACB Table View'''
+
+    AcbGuid: bytes
+    '''GUID of the ACB. This SHOULD be different for each ACB file.'''
+    Name: str
+    '''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]
+    TrackTable: List[TrackTable]
+    WaveformTable: List[WaveformTable]
+
+    @staticmethod
+    def _decode_tlv(data : bytes):
+        pos = 0
+        while pos < len(data):
+            tag = data[pos : pos + 2]
+            length = data[pos + 3]            
+            value = data[pos + 4 : pos + 4 + length]
+            pos += 3 + length
+            yield (tag, value)
+
+    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)
+                case 0x03: # Sequence
+                    yield from self._waveform_of_sequence(tlv_index)
+                # Ignore others silently                
+        for code, data in tlv:
+            match code:
+                case 2000:
+                    yield from noteOn(data)
+                case 2003:
+                    yield from noteOn(data)            
+
+    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):        
+        item_type, item_index = AcbSynthReferenceStruct.unpack(self.SynthTable[index].ReferenceItems)
+        match item_type:
+            case 0x00: # No audio
+                return
+            case 0x01: # Waveform
+                yield self.WaveformTable[item_index]
+            case 0x02: # Yet another synth...
+                yield from self._waveform_of_synth(item_index)
+            case 0x03: # Sequence
+                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))
+            case 0x03:
+                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 PackedCueItem:
+    '''Helper class for read-only cue information'''
+
+    CueId: int
+    '''Cue ID'''
+    CueName: str
+    '''Cue name'''
+    Length: float
+    '''Duration in seconds'''
+    Waveforms: list[int]
+    '''List of waveform IDs, corresponds to ACB.get_waveforms()'''
+
+class ACB(UTF):
+    """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:
+        """Retrives the only 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.
+        
+        * Use this to interact with the ACB payload instead of `payload` for helper functions, etc"""
+        return ACBTable(self.payload)
+
+    @property
+    def name(self) -> str:
+        """Returns the name of the ACB file."""
+        return self.view.Name
+
+    @property
+    def awb(self) -> AWB:
+        """Returns the AWB object associated with the ACB."""
+        return AWB(self.view.AwbFile)
+
+    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,
+            AcbEncodeTypes.HCA: HCACodec,
+            AcbEncodeTypes.HCAMX: HCACodec,
+        }
+        awb = self.awb
+        wavs = []        
+        for wav in self.view.WaveformTable:
+            encode = AcbEncodeTypes(wav.EncodeType)
+            codec = (CODEC_TABLE.get(encode, None))
+            if codec:
+                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
+
+    def set_waveforms(self, value: List[HCACodec | ADXCodec | Tuple[AcbEncodeTypes, int, int, int, bytes]]):
+        """Sets the waveform data.
+
+        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 - this is usually unecessary as the player will just play until the end of the waveform.
+        """
+        WAVEFORM = self.view.WaveformTable[0]._payload.copy()
+        encoded = []
+        tables = self.view.WaveformTable
+        tables.clear()
+        for i, codec in enumerate(value):
+            if type(codec) == HCACodec:
+                encoded.append(codec.get_encoded())
+                tables.append(WaveformTable(WAVEFORM.copy()))
+                entry = tables[-1]
+                entry.EncodeType = AcbEncodeTypes.HCA.value
+                entry.NumChannels = codec.chnls
+                entry.NumSamples = codec.total_samples
+                entry.SamplingRate = codec.sampling_rate
+            elif type(codec) == ADXCodec:
+                encoded.append(codec.get_encoded())
+                tables.append(WaveformTable(WAVEFORM.copy()))
+                entry = tables[-1]
+                entry.EncodeType = AcbEncodeTypes.ADX.value
+                entry.NumChannels = codec.chnls
+                entry.NumSamples = codec.total_samples
+                entry.SamplingRate = codec.sampling_rate                
+            elif isinstance(codec, tuple):
+                e_type, e_channels, e_samples, e_rate, e_data = codec
+                encoded.append(e_data)
+                tables.append(WaveformTable(WAVEFORM.copy()))
+                entry = tables[-1]
+                entry.EncodeType = e_type.value
+                entry.NumChannels = e_channels
+                entry.NumSamples = e_samples
+                entry.SamplingRate = e_rate
+            else:
+                raise TypeError(f"Unsupported codec type: {type(codec)}")
+            tables[-1].MemoryAwbId = i
+        awb = self.awb
+        self.view.AwbFile = AWBBuilder(encoded, awb.subkey, awb.version, align=awb.align).build()
+        pass
+
+    @property
+    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`.
+        To modify cues, use the `view` property instead.
+        """
+        for name, cue in zip(self.view.CueNameTable, self.view.CueTable):
+            waveforms = self.view.waveform_of(cue.CueId)
+            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.
+
+        Maybe one day I'll get around to this. But otherwise starting from nothing is a WONTFIX for now.
+        """
+        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.
+        """
+        # Check whether all AWB indices are valid
+        assert all(
+            waveform.MemoryAwbId < self.acb.awb.numfiles for waveform in self.acb.view.WaveformTable
+        ), "one or more AWB indices are out of range"
+        binary = UTFBuilder(self.acb.dictarray, encoding=self.acb.encoding, table_name=self.acb.table_name)
+        return binary.bytes()

PyCriCodecsEx/adx.py

@@ -0,0 +1,158 @@
+from typing import BinaryIO
+from io import BytesIO
+from PyCriCodecsEx.chunk import *
+import CriCodecsEx
+class ADX:
+    """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:
+        """ 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)
+    
+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

@@ -0,0 +1,165 @@
+from io import BytesIO, FileIO
+from typing import BinaryIO, Generator
+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 : str | BinaryIO) -> None:
+        """Initializes the AWB object
+
+        Args:
+            stream (str | BinaryIO): Source file path or binary stream
+        """
+        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[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)):
+            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) -> bytes:
+        """Gets you a file at specific index. """
+        self.stream.seek(self.ofs[index], 0)
+        data = self.stream.read(self.ofs[index + 1]-self.ofs[index])
+        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:
+    """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.
+
+        Args:
+            infiles (list[bytes]): List of bytes to be included in the AWB file.
+            subkey (int, optional): AWB subkey. Defaults to 0.
+            version (int, optional): AWB version. Defaults to 2.
+            id_intsize (hexadecimal, optional): Integer size (in bytes) for string lengths. Defaults to 0x2.
+            align (int, optional): Alignment. Defaults to 0x20.
+        """
+        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:
+        """Builds the AWB file from the provided infiles 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()