PyCriCodecsEx 0.0.1__tar.gz

pycricodecsex-0.0.1/CriCodecsEx/CriCodecsEx.cpp

@@ -0,0 +1,29 @@
+#define PY_SSIZE_T_CLEAN
+#pragma once
+#include <Python.h>
+#include "adx.cpp"
+#include "crilayla.cpp"
+#include "hca.cpp"
+
+static struct PyMethodDef Codec_methods[] = {
+    { "AdxDecode", (PyCFunction)AdxDecode, METH_O, nullptr },
+    { "AdxEncode", (PyCFunction)AdxEncode, METH_VARARGS, nullptr },
+    { "CriLaylaDecompress", (PyCFunction)CriLaylaDecompress, METH_O, nullptr },
+    { "CriLaylaCompress", (PyCFunction)CriLaylaCompress, METH_VARARGS, nullptr },
+    { "HcaDecode", (PyCFunction)HcaDecode, METH_VARARGS, nullptr },
+    { "HcaEncode", (PyCFunction)HcaEncode, METH_VARARGS, nullptr },
+    { "HcaCrypt", (PyCFunction)HcaCrypt, METH_VARARGS, nullptr },
+    { nullptr, nullptr, 0, nullptr }
+};
+
+static PyModuleDef CriCodecsEx_module = {
+    PyModuleDef_HEAD_INIT,
+    "CriCodecs",
+    "Faster Decoding and Encoding with C++",
+    0,
+    Codec_methods
+};
+
+PyMODINIT_FUNC PyInit_CriCodecsEx() {
+    return PyModule_Create(&CriCodecsEx_module);
+}

pycricodecsex-0.0.1/CriCodecsEx/IO.cpp

@@ -0,0 +1,182 @@
+/**
+ * @file IO.cpp
+ * @brief Read/Write handler for cross-platform endiannes.
+ * Most of what's here is ports from other libraries. VGAudio and VGMStream to name a few. 
+ */
+
+/* Includes */
+#include "IO.hpp"
+#include <algorithm>
+
+void WriteChar(unsigned char* Buffer, unsigned char Value){
+    Buffer[0] = Value;
+}
+
+void WriteShortLE(unsigned char* Buffer, unsigned short Value){
+    Buffer[0] = Value & 0xFF;
+    Buffer[1] = Value >> 8;
+}
+
+void WriteShortBE(unsigned char* Buffer, unsigned short Value){
+    Buffer[0] = Value >> 8;
+    Buffer[1] = Value & 0xFF;
+}
+
+void WriteIntLE(unsigned char* Buffer, unsigned int Value){
+    Buffer[0] = (unsigned char)(Value & 0xFF);
+    Buffer[1] = (unsigned char)((Value >> 8) & 0xFF);
+    Buffer[2] = (unsigned char)((Value >> 16) & 0xFF);
+    Buffer[3] = (unsigned char)((Value >> 24) & 0xFF);
+}
+
+void WriteIntBE(unsigned char* Buffer, unsigned int Value){
+    Buffer[0] = (unsigned char)((Value >> 24) & 0xFF);
+    Buffer[1] = (unsigned char)((Value >> 16) & 0xFF);
+    Buffer[2] = (unsigned char)((Value >> 8) & 0xFF);
+    Buffer[3] = (unsigned char)(Value & 0xFF);
+}
+
+unsigned long long BitReader::GetBitsRemaining(){
+    return Length - Position;
+}
+
+void BitReader::SetBuffer(unsigned char* buffer, unsigned int size){
+    Buffer = buffer;
+    Length = size * 8;
+    Position = 0;
+}
+
+int BitReader::ReadInt(int BitCount){
+    int value = PeekInt(BitCount);
+    Position += BitCount;
+    return value;
+}
+
+int BitReader::ReadSignedInt(int BitCount){
+    int value = PeekInt(BitCount);
+    Position += BitCount;
+    return SignExtend(value, BitCount);
+}
+
+template<typename T> T BitReader::SignExtend(T value, int bits){
+    int shift = sizeof(T) * 8 - bits;
+    return (value << shift) >> shift;
+}
+
+void BitReader::AlignPosition(int multiple){
+    Position = GetNextMultiple(Position, multiple);
+}
+
+int BitReader::PeekInt(int BitCount){
+    unsigned long long Remaining = GetBitsRemaining();
+    if (BitCount > Remaining){
+        if (Position >= Length) return 0;
+        int ExtraBits = BitCount - Remaining;
+        return PeekIntFallback(Remaining) << ExtraBits;
+    }
+    int ByteIndex = Position / 8;
+    int BitIndex = Position % 8;
+    if (BitCount <= 9 && Remaining >= 16){
+        int value = Buffer[ByteIndex] << 8 | Buffer[ByteIndex + 1];
+        value &= 0xFFFF >> BitIndex;
+        value >>= 16 - BitCount - BitIndex;
+        return value;
+    }
+    if (BitCount <= 17 && Remaining >= 24){
+        int value = Buffer[ByteIndex] << 16 | Buffer[ByteIndex + 1] << 8 | Buffer[ByteIndex + 2];
+        value &= 0xFFFFFF >> BitIndex;
+        value >>= 24 - BitCount - BitIndex;
+        return value;
+    }
+    if (BitCount <= 25 && Remaining >= 32){
+        int value = Buffer[ByteIndex] << 24 | Buffer[ByteIndex + 1] << 16 | Buffer[ByteIndex + 2] << 8 | Buffer[ByteIndex + 3];
+        value &= (int)(0xFFFFFFFF >> BitIndex);
+        value >>= 32 - BitCount - BitIndex;
+        return value;
+    }
+    return PeekIntFallback(BitCount);
+}
+
+int BitReader::PeekIntFallback(int BitCount){
+    int value = 0;
+    int ByteIndex = Position / 8;
+    int BitIndex = Position % 8;
+    while (BitCount > 0){
+        if (BitIndex >= 8){
+            BitIndex = 0;
+            ByteIndex++;
+        }
+        int bitsToRead = std::min(BitCount, 8 - BitIndex);
+        int mask = 0xFF >> BitIndex;
+        int currentByte = (mask & Buffer[ByteIndex]) >> (8 - BitIndex - bitsToRead);
+        value = (value << bitsToRead) | currentByte;
+        BitIndex += bitsToRead;
+        BitCount -= bitsToRead;
+    }
+    return value;
+}
+
+void BitWriter::SetBuffer(unsigned char* buffer, unsigned int size){
+    Buffer = buffer;
+    Length = size * 8;
+    Position = 0;
+}
+
+unsigned long long BitWriter::GetBitsRemaining(){
+    return Length - Position;
+}
+
+void BitWriter::Write(int value, int BitCount){
+    unsigned long long Remaining = GetBitsRemaining();
+    if(BitCount < 0 || BitCount > 32)
+        return;
+    else if(BitCount > Remaining)
+        return;
+    int ByteIndex = Position / 8;
+    int BitIndex = Position % 8;
+    if (BitCount <= 9 && GetBitsRemaining() >= 16){
+        unsigned int outValue = ((value << (16 - BitCount)) & 0xFFFF) >> BitIndex;
+        Buffer[ByteIndex] |= (unsigned char)(outValue >> 8);
+        Buffer[ByteIndex + 1] = (unsigned char)outValue;
+    }else if (BitCount <= 17 && GetBitsRemaining() >= 24){
+        int outValue = ((value << (24 - BitCount)) & 0xFFFFFF) >> BitIndex;
+        Buffer[ByteIndex] |= (unsigned char)(outValue >> 16);
+        Buffer[ByteIndex + 1] = (unsigned char)(outValue >> 8);
+        Buffer[ByteIndex + 2] = (unsigned char)outValue;
+    }else if (BitCount <= 25 && GetBitsRemaining() >= 32){
+        unsigned int outValue = (unsigned int)(((value << (32 - BitCount)) & 0xFFFFFFFF) >> BitIndex);
+        Buffer[ByteIndex] |= (unsigned char)(outValue >> 24);
+        Buffer[ByteIndex + 1] = (unsigned char)(outValue >> 16);
+        Buffer[ByteIndex + 2] = (unsigned char)(outValue >> 8);
+        Buffer[ByteIndex + 3] = (unsigned char)outValue;
+    }else{
+        WriteFallback(value, BitCount);
+    }
+    Position += BitCount;
+}
+
+void BitWriter::AlignPosition(int multiple){
+    int newPosition = GetNextMultiple(Position, multiple);
+    int bits = newPosition - Position;
+    Write(0, bits);
+}
+
+void BitWriter::WriteFallback(int value, int BitCount){
+    int ByteIndex = Position / 8;
+    int BitIndex = Position % 8;
+    while(BitCount > 0){
+        if(BitIndex >= 8){
+            BitIndex = 0;
+            ByteIndex++;
+        }
+        int toShift = 8 - BitIndex - BitCount;
+        int shifted = toShift < 0 ? value >> -toShift : value << toShift;
+        int bitsToWrite = std::min(BitCount, 8 - BitIndex);
+        int mask = ((1 << bitsToWrite) - 1) << 8 - BitIndex - bitsToWrite;
+        int outByte = Buffer[ByteIndex] & ~mask;
+        outByte |= shifted & mask;
+        Buffer[ByteIndex] = (unsigned char)outByte;
+        BitIndex += bitsToWrite;
+        BitCount -= bitsToWrite;
+    }
+}

pycricodecsex-0.0.1/CriCodecsEx/IO.hpp

@@ -0,0 +1,77 @@
+static inline short ReadShortBE(const unsigned char* ptr){
+    return (ptr[0] << 8) | ptr[1];
+}
+static inline short ReadShortLE(const unsigned char* ptr){
+    return ptr[0] | (ptr[1] << 8);
+}
+static inline int ReadIntBE(const unsigned char* ptr){
+    return (ptr[0] << 24) | (ptr[1] << 16) | (ptr[2] << 8) | ptr[3];
+}
+static inline int ReadIntLE(const unsigned char* ptr){
+    return ptr[0] | (ptr[1] << 8) | (ptr[2] << 16) | (ptr[3] << 24);
+}
+static inline long long ReadLongLongBE(const unsigned char* ptr) {
+    return (unsigned long long)(((unsigned long long)ptr[0] << 56) | ((unsigned long long)ptr[1] << 48) | ((unsigned long long)ptr[2] << 40) | ((unsigned long long)ptr[3] << 32) | ((unsigned long long)ptr[4] << 24) | ((unsigned long long)ptr[5] << 16) | ((unsigned long long)ptr[6] << 8) | (unsigned long long)ptr[7]);
+}
+static inline long long ReadLongLongLE(const unsigned char* ptr) {
+    return (unsigned long long)((unsigned long long)ptr[0] | ((unsigned long long)ptr[1] << 8) | ((unsigned long long)ptr[2] << 16) | ((unsigned long long)ptr[3] << 24) | ((unsigned long long)ptr[4] << 32) | ((unsigned long long)ptr[5] << 40) | ((unsigned long long)ptr[6] << 48) | ((unsigned long long)ptr[7] << 56));
+}
+static inline unsigned short ReadUnsignedShortBE(const unsigned char* ptr){return (unsigned short)ReadShortBE(ptr);}
+static inline unsigned short ReadUnsignedShortLE(const unsigned char* ptr){return (unsigned short)ReadShortLE(ptr);}
+static inline unsigned int ReadUnsignedIntBE(const unsigned char* ptr){return (unsigned int)ReadIntBE(ptr);}
+static inline unsigned int ReadUnsignedIntLE(const unsigned char* ptr){return (unsigned int)ReadIntLE(ptr);}
+static inline unsigned long long ReadUnsignedLongLongBE(const unsigned char* ptr){return (unsigned long long)ReadLongLongBE(ptr);}
+static inline unsigned long long ReadUnsignedLongLongLE(const unsigned char* ptr){return (unsigned long long)ReadLongLongLE(ptr);}
+
+static inline int GetNextMultiple(int value, int multiple){
+    if (multiple <= 0)
+        return value;
+    if (value % multiple == 0)
+        return value;
+    return value + multiple - value % multiple;
+}
+
+void WriteChar(unsigned char* Buffer, unsigned char Value);
+void WriteShortLE(unsigned char* Buffer, unsigned short Value);
+void WriteShortBE(unsigned char* Buffer, unsigned short Value);
+void WriteIntLE(unsigned char* Buffer, unsigned int Value);
+void WriteIntBE(unsigned char* Buffer, unsigned int Value);
+
+struct BitReader{
+    unsigned char* Buffer;
+    unsigned long long Length;
+    unsigned int Position;
+
+    unsigned long long GetBitsRemaining();
+    void SetBuffer(unsigned char* buffer, unsigned int size);
+    int ReadInt(int BitCount);
+    int ReadSignedInt(int BitCount);
+    template<typename T> T SignExtend(T value, int bits);
+    void AlignPosition(int multiple);
+    int PeekInt(int BitCount);
+    int PeekIntFallback(int BitCount);
+};
+
+struct BitWriter{
+    unsigned char* Buffer;
+    unsigned long long Length;
+    unsigned int Position;
+    void SetBuffer(unsigned char *buffer, unsigned int size);
+    unsigned long long GetBitsRemaining();
+    void Write(int value, int BitCount);
+    void AlignPosition(int multiple);
+    void WriteFallback(int value, int BitCount);
+};
+
+struct GUID{
+    unsigned int guid1;
+    unsigned short guid2;
+    unsigned short guid3;
+    unsigned long long guid4;
+    inline void loadGUID(const unsigned char *data){
+        guid1 = ReadUnsignedIntLE(data+0);
+        guid2 = ReadUnsignedShortLE(data+4);
+        guid3 = ReadUnsignedShortLE(data+6);
+        guid4 = ReadUnsignedLongLongLE(data+8);
+    }
+};