ReverseBox 0.18.2__tar.gz → 0.18.4__tar.gz

{ReverseBox-0.18.2 → ReverseBox-0.18.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ReverseBox
-Version: 0.18.2
+Version: 0.18.4
 Summary: A set of functions useful in reverse engineering.
 Home-page: https://github.com/bartlomiejduda/ReverseBox
 Author: Bartlomiej Duda

{ReverseBox-0.18.2 → ReverseBox-0.18.4}/ReverseBox.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ReverseBox
-Version: 0.18.2
+Version: 0.18.4
 Summary: A set of functions useful in reverse engineering.
 Home-page: https://github.com/bartlomiejduda/ReverseBox
 Author: Bartlomiej Duda

{ReverseBox-0.18.2 → ReverseBox-0.18.4}/ReverseBox.egg-info/SOURCES.txt

@@ -63,6 +63,10 @@ reversebox/image/image_formats.py
 reversebox/image/pillow_wrapper.py
 reversebox/image/compression/__init__.py
 reversebox/image/compression/compression_gst.py
+reversebox/image/decoders/__init__.py
+reversebox/image/decoders/bumpmap_decoder.py
+reversebox/image/decoders/n64_decoder.py
+reversebox/image/decoders/yuv_decoder.py
 reversebox/image/file_formats/__init__.py
 reversebox/image/file_formats/image_dds.py
 reversebox/image/palettes/__init__.py

ReverseBox-0.18.4/reversebox/compression/compression_refpack.py

@@ -0,0 +1,68 @@
+"""
+Copyright © 2024  Bartłomiej Duda
+License: GPL-3.0 License
+"""
+import ctypes
+from ctypes import c_char
+
+from reversebox.common.common import get_dll_path
+
+# fmt: off
+
+
+class RefpackHandler:
+    def compress_data(self, uncompressed_data: bytes) -> bytes:
+        if len(uncompressed_data) == 0:
+            raise Exception("Data is empty! Nothing to compress!")
+
+        maxback: int = 131072
+        quick: int = 0
+
+        c_uncompressed_data_len = ctypes.c_uint(len(uncompressed_data))
+        c_uncompressed_data = (ctypes.c_ubyte * len(uncompressed_data))(*uncompressed_data)
+        c_compressed_data_buffer = (c_char * int(len(uncompressed_data)*5))()  # just in case
+        c_options_maxback = ctypes.c_uint(maxback)
+        c_options_quick = ctypes.c_uint(quick)
+
+        try:
+            refpack_dll_path: str = get_dll_path("refpack.dll")
+            refpack_dll_file = ctypes.CDLL(refpack_dll_path)
+            compressed_data_size = refpack_dll_file.refpack_compress(ctypes.byref(c_compressed_data_buffer), c_uncompressed_data, c_uncompressed_data_len, ctypes.byref(c_options_maxback), ctypes.byref(c_options_quick))
+        except Exception as error:
+            raise Exception(f"Error while decompressing refpack data! Error: {error}")
+        return bytes(bytearray(c_compressed_data_buffer)[:compressed_data_size])
+
+    def _get_output_buffer_size(self, compressed_data: bytes) -> int:
+        current_input_offset: int = 0
+        compression_type = compressed_data[current_input_offset]
+        current_input_offset += 1
+        compression_type = (compression_type << 8) + compressed_data[current_input_offset]
+        current_input_offset += 1
+
+        if compression_type & 0x100:
+            current_input_offset += 3  # skip uncompressed_size
+
+        uncompressed_size: int = compressed_data[current_input_offset]
+        current_input_offset += 1
+        uncompressed_size = (uncompressed_size << 8) + compressed_data[current_input_offset]
+        current_input_offset += 1
+        uncompressed_size = (uncompressed_size << 8) + compressed_data[current_input_offset]
+        current_input_offset += 1
+        return uncompressed_size
+
+    def decompress_data(self, compressed_data: bytes) -> bytes:
+        if len(compressed_data) < 5:
+            raise Exception("Compressed data too short!")
+        if compressed_data[:2] != b"\x10\xFB":
+            raise Exception("Wrong refpack compression header!")
+
+        uncompressed_data_buffer = (c_char * self._get_output_buffer_size(compressed_data))()
+        compressed_data_len = ctypes.c_uint(len(compressed_data))
+
+        try:
+            refpack_dll_path: str = get_dll_path("refpack.dll")
+            refpack_dll_file = ctypes.CDLL(refpack_dll_path)
+            uncompressed_data_size = refpack_dll_file.refpack_decompress(ctypes.byref(uncompressed_data_buffer), compressed_data, ctypes.byref(compressed_data_len))
+        except Exception as error:
+            raise Exception(f"Error while decompressing refpack data! Error: {error}")
+        return bytes(bytearray(uncompressed_data_buffer)[:uncompressed_data_size])

ReverseBox-0.18.4/reversebox/image/decoders/bumpmap_decoder.py

@@ -0,0 +1,58 @@
+"""
+Copyright © 2024  Bartłomiej Duda
+License: GPL-3.0 License
+"""
+import math
+
+from reversebox.common.logger import get_logger
+from reversebox.image.image_formats import ImageFormats
+
+logger = get_logger(__name__)
+
+# fmt: off
+
+
+class BumpmapDecoder:
+
+    def __init__(self):
+        pass
+
+    # 16-bit normal map. Each texel consist of a pair of 8-bit values (S and R)
+    # which represent a normal in spherical coordinates.
+    # S = polar angle. 0-255 maps to 0-89 degrees.
+    # R = azimuthal angle. 0-255 maps to 0-359 degrees.
+    # Used in DTEX Texconv Tool
+    def _decode_bumpmap_sr_image(self, image_data: bytes, img_width: int, img_height: int) -> bytes:
+        rgba_data = bytearray(img_width * img_height * 4)
+
+        for i in range(img_width * img_height):
+            S = image_data[i * 2]
+            R = image_data[i * 2 + 1]
+
+            polar_angle = S * 89.0 / 255.0
+            azimuthal_angle = R * 359.0 / 255.0
+
+            polar_radians = math.radians(polar_angle)
+            azimuthal_radians = math.radians(azimuthal_angle)
+
+            nx = math.sin(polar_radians) * math.cos(azimuthal_radians)
+            ny = math.sin(polar_radians) * math.sin(azimuthal_radians)
+            nz = math.cos(polar_radians)
+
+            r_value = int((nx + 1.0) * 127.5)
+            g_value = int((ny + 1.0) * 127.5)
+            b_value = int((nz + 1.0) * 127.5)
+
+            rgba_data[i * 4] = r_value
+            rgba_data[i * 4 + 1] = g_value
+            rgba_data[i * 4 + 2] = b_value
+            rgba_data[i * 4 + 3] = 0xFF
+
+        return rgba_data
+
+    def decode_bumpmap_image_main(self, image_data: bytes, img_width: int, img_height: int, image_format: ImageFormats) -> bytes:
+
+        if image_format == ImageFormats.BUMPMAP_SR:
+            return self._decode_bumpmap_sr_image(image_data, img_width, img_height)
+        else:
+            raise Exception(f"Image format not supported by BUMPMAP decoder! Image_format: {image_format}")

ReverseBox-0.18.4/reversebox/image/decoders/n64_decoder.py

@@ -0,0 +1,100 @@
+"""
+Copyright © 2024  Bartłomiej Duda
+License: GPL-3.0 License
+"""
+
+from reversebox.common.logger import get_logger
+from reversebox.image.common import crop_image, get_storage_wh
+from reversebox.image.image_formats import ImageFormats
+from reversebox.io_files.bytes_handler import BytesHandler
+from reversebox.io_files.bytes_helper_functions import get_uint8, get_uint16
+
+logger = get_logger(__name__)
+
+# fmt: off
+# mypy: ignore-errors
+
+
+class N64Decoder:
+
+    def __init__(self):
+        pass
+
+    def _decode_n64_rgba32_image(self, image_data: bytes, img_width: int, img_height: int, block_width: int, block_height: int) -> bytes:
+        _width, _height = get_storage_wh(img_width, img_height, block_width, block_height)
+        output_data = bytearray(_width * _height * 4)
+        offset = 0
+
+        for y in range(0, _height, block_height):
+            for x in range(0, _width, block_width):
+                for y2 in range(block_height):
+                    for x2 in range(block_width):
+                        idx = (((y + y2) * _width) + (x + x2)) * 4
+                        output_data[idx + 0] = image_data[offset + 1]
+                        output_data[idx + 1] = image_data[offset + 32]
+                        output_data[idx + 2] = image_data[offset + 33]
+                        output_data[idx + 3] = image_data[offset + 0]
+                        offset += 2
+                offset += 32
+
+        output_data = crop_image(output_data, _width, _height, 32, img_width, img_height)
+        return output_data
+
+    def _decode_n64_cmpr_image(self, image_data: bytes, img_width: int, img_height: int, block_width: int, block_height: int) -> bytes:
+        _width, _height = get_storage_wh(img_width, img_height, block_width, block_height)
+        output_data = bytearray(_width * _height * 4)
+        image_data_handler = BytesHandler(image_data)
+
+        def _decode_rgb565_pixel(pixel_int: int) -> bytes:
+            p = bytearray(4)
+            p[0] = ((pixel_int >> 11) & 0x1F) * 0xFF // 0x1F
+            p[1] = ((pixel_int >> 5) & 0x3F) * 0xFF // 0x3F
+            p[2] = ((pixel_int >> 0) & 0x1F) * 0xFF // 0x1F
+            p[3] = 0xFF
+            return p
+
+        current_offset: int = 0
+        for y in range(0, _height, block_height):
+            for x in range(0, _width, block_width):
+                for y2 in range(0, block_height, 4):
+                    for x2 in range(0, block_width, 4):
+
+                        c0 = get_uint16(image_data_handler.get_bytes(current_offset, 2), ">")
+                        current_offset += 2
+                        c1 = get_uint16(image_data_handler.get_bytes(current_offset, 2), ">")
+                        current_offset += 2
+
+                        c = [
+                            _decode_rgb565_pixel(c0),
+                            _decode_rgb565_pixel(c1),
+                            bytearray(4),
+                            bytearray(4)
+                        ]
+
+                        if c0 > c1:
+                            for i in range(4):
+                                c[2][i] = int((2 * c[0][i] + c[1][i]) / 3)
+                                c[3][i] = int((2 * c[1][i] + c[0][i]) / 3)
+                        else:
+                            for i in range(4):
+                                c[2][i] = int((c[0][i] + c[1][i]) * .5)
+                                c[3][i] = 0
+
+                        for y3 in range(4):
+                            b = get_uint8(image_data_handler.get_bytes(current_offset, 1), ">")
+                            current_offset += 1
+                            for x3 in range(4):
+                                idx = (((y + y2 + y3) * _width) + (x + x2 + x3)) * 4
+                                output_data[idx: idx + 4] = c[(b >> (6 - (x3 * 2))) & 0x3]
+
+        output_data = crop_image(output_data, _width, _height, 32, img_width, img_height)
+        return output_data
+
+    def decode_n64_image_main(self, image_data: bytes, img_width: int, img_height: int, image_format: ImageFormats) -> bytes:
+
+        if image_format == ImageFormats.N64_RGBA32:
+            return self._decode_n64_rgba32_image(image_data, img_width, img_height, 4, 4)
+        elif image_format == ImageFormats.N64_CMPR:
+            return self._decode_n64_cmpr_image(image_data, img_width, img_height, 8, 8)
+        else:
+            raise Exception(f"Image format not supported by N64 decoder! Image_format: {image_format}")

ReverseBox-0.18.4/reversebox/image/decoders/yuv_decoder.py

@@ -0,0 +1,519 @@
+"""
+Copyright © 2024  Bartłomiej Duda
+License: GPL-3.0 License
+"""
+
+
+from reversebox.common.logger import get_logger
+from reversebox.image.image_formats import ImageFormats
+
+logger = get_logger(__name__)
+
+# fmt: off
+
+
+class YUVDecoder:
+
+    def __init__(self):
+        pass
+
+    def _check_if_yuv_image_dimensions_are_correct(self, img_width: int, img_height: int) -> bool:
+        MIN_IMAGE_WIDTH = 4
+        MIN_IMAGE_HEIGHT = 4
+
+        if img_width < MIN_IMAGE_WIDTH or img_height < MIN_IMAGE_HEIGHT:
+            raise Exception("YUV image to small to convert!")
+
+        return True
+
+    def _limit_rgb_value(self, f: float) -> int:
+        i: int = int(f + 0.5)
+        if i < 0:
+            i = 0
+        if i > 255:
+            i = 255
+        return i
+
+    def _yuv_to_rgb(self, Y, U, V) -> tuple:
+        R = Y + 1.140 * (V - 128)
+        G = Y - 0.395 * (U - 128) - 0.581 * (V - 128)
+        B = Y + 2.032 * (U - 128)
+
+        R = self._limit_rgb_value(R)
+        G = self._limit_rgb_value(G)
+        B = self._limit_rgb_value(B)
+
+        return R, G, B
+
+    def _decode_yuy2_pixel(self, Y: float, U: float, V: float) -> bytes:
+        p = bytearray(4)
+
+        C: float = Y - 16.0
+        D: float = U - 128.0
+        E: float = V - 128.0
+
+        R: float = 1.164383 * C + 1.596027 * E
+        G: float = 1.164383 * C - (0.391762 * D) - (0.812968 * E)
+        B: float = 1.164383 * C + 2.017232 * D
+
+        p[0] = self._limit_rgb_value(R)
+        p[1] = self._limit_rgb_value(G)
+        p[2] = self._limit_rgb_value(B)
+        p[3] = 0xFF
+        return p
+
+    def _decode_yuv422_yuy2_image(self, image_data: bytes, img_width: int, img_height: int) -> bytes:
+        is_width_odd: bool = True if (img_width & 1) else False
+        current_yuv_offset: int = 0
+        current_pixel_number: int = 0
+        output_texture_data = bytearray(img_width * img_height * 4)
+
+        for y in range(img_height):
+            for x in range(0, img_width, 2):
+
+                Y0: float = float(image_data[current_yuv_offset])
+                U: float = float(image_data[current_yuv_offset + 1])
+                Y1: float = float(image_data[current_yuv_offset + 2])
+                V: float = float(image_data[current_yuv_offset + 3])
+
+                pixel1 = self._decode_yuy2_pixel(Y0, U, V)
+                pixel2 = self._decode_yuy2_pixel(Y1, U, V)
+                output_texture_data[current_pixel_number * 4:(current_pixel_number + 1) * 4] = pixel1
+                output_texture_data[(current_pixel_number + 1) * 4:(current_pixel_number + 2) * 4] = pixel2
+
+                if is_width_odd and x == img_width - 1:
+                    current_yuv_offset += 4
+                    current_pixel_number += 1
+                else:
+                    current_yuv_offset += 4
+                    current_pixel_number += 2
+
+        return output_texture_data
+
+    def _decode_yuv420_nv12_image(self, image_data: bytes, img_width: int, img_height: int) -> bytes:
+        output_texture_data = bytearray(img_width * img_height * 4)
+
+        p: int = img_height
+        for i in range(0, img_height, 2):
+            for j in range(0, img_width, 2):
+                Y00 = float(image_data[i * img_width + j])
+                Y01 = float(image_data[i * img_width + j + 1])
+                Y10 = float(image_data[(i + 1) * img_width + j])
+                Y11 = float(image_data[(i + 1) * img_width + j + 1])
+                U = float(image_data[p * img_width + j])
+                V = float(image_data[p * img_width + j + 1])
+
+                R = Y00 + 1.140 * (V - 128.0)
+                G = Y00 - 0.395 * (U - 128.0) - 0.581 * (V - 128.0)
+                B = Y00 + 2.032 * (U - 128.0)
+                output_texture_data[i * img_width * 4 + j * 4] = self._limit_rgb_value(R)
+                output_texture_data[i * img_width * 4 + j * 4 + 1] = self._limit_rgb_value(G)
+                output_texture_data[i * img_width * 4 + j * 4 + 2] = self._limit_rgb_value(B)
+                output_texture_data[i * img_width * 4 + j * 4 + 3] = 0xFF
+
+                R = Y01 + 1.140 * (V - 128.0)
+                G = Y01 - 0.395 * (U - 128.0) - 0.581 * (V - 128.0)
+                B = Y01 + 2.032 * (U - 128.0)
+                output_texture_data[i * img_width * 4 + j * 4 + 4] = self._limit_rgb_value(R)
+                output_texture_data[i * img_width * 4 + j * 4 + 5] = self._limit_rgb_value(G)
+                output_texture_data[i * img_width * 4 + j * 4 + 6] = self._limit_rgb_value(B)
+                output_texture_data[i * img_width * 4 + j * 4 + 7] = 0xFF
+
+                R = Y10 + 1.140 * (V - 128.0)
+                G = Y10 - 0.395 * (U - 128.0) - 0.581 * (V - 128.0)
+                B = Y10 + 2.032 * (U - 128.0)
+                output_texture_data[(i + 1) * img_width * 4 + j * 4] = self._limit_rgb_value(R)
+                output_texture_data[(i + 1) * img_width * 4 + j * 4 + 1] = self._limit_rgb_value(G)
+                output_texture_data[(i + 1) * img_width * 4 + j * 4 + 2] = self._limit_rgb_value(B)
+                output_texture_data[(i + 1) * img_width * 4 + j * 4 + 3] = 0xFF
+
+                R = Y11 + 1.140 * (V - 128.0)
+                G = Y11 - 0.395 * (U - 128.0) - 0.581 * (V - 128.0)
+                B = Y11 + 2.032 * (U - 128.0)
+                output_texture_data[(i + 1) * img_width * 4 + j * 4 + 4] = self._limit_rgb_value(R)
+                output_texture_data[(i + 1) * img_width * 4 + j * 4 + 5] = self._limit_rgb_value(G)
+                output_texture_data[(i + 1) * img_width * 4 + j * 4 + 6] = self._limit_rgb_value(B)
+                output_texture_data[(i + 1) * img_width * 4 + j * 4 + 7] = 0xFF
+
+            p += 1
+
+        return output_texture_data
+
+    def _decode_yuv420_nv21_image(self, image_data: bytes, img_width: int, img_height: int) -> bytes:
+        output_texture_data = bytearray(img_width * img_height * 4)
+
+        p: int = img_height
+        for i in range(0, img_height, 2):
+            for j in range(0, img_width, 2):
+                Y00 = float(image_data[i * img_width + j])
+                Y01 = float(image_data[i * img_width + j + 1])
+                Y10 = float(image_data[(i + 1) * img_width + j])
+                Y11 = float(image_data[(i + 1) * img_width + j + 1])
+                U = float(image_data[p * img_width + j + 1])
+                V = float(image_data[p * img_width + j])
+
+                R = Y00 + 1.140 * (V - 128.0)
+                G = Y00 - 0.395 * (U - 128.0) - 0.581 * (V - 128.0)
+                B = Y00 + 2.032 * (U - 128.0)
+                output_texture_data[i * img_width * 4 + j * 4] = self._limit_rgb_value(R)
+                output_texture_data[i * img_width * 4 + j * 4 + 1] = self._limit_rgb_value(G)
+                output_texture_data[i * img_width * 4 + j * 4 + 2] = self._limit_rgb_value(B)
+                output_texture_data[i * img_width * 4 + j * 4 + 3] = 0xFF
+
+                R = Y01 + 1.140 * (V - 128.0)
+                G = Y01 - 0.395 * (U - 128.0) - 0.581 * (V - 128.0)
+                B = Y01 + 2.032 * (U - 128.0)
+                output_texture_data[i * img_width * 4 + j * 4 + 4] = self._limit_rgb_value(R)
+                output_texture_data[i * img_width * 4 + j * 4 + 5] = self._limit_rgb_value(G)
+                output_texture_data[i * img_width * 4 + j * 4 + 6] = self._limit_rgb_value(B)
+                output_texture_data[i * img_width * 4 + j * 4 + 7] = 0xFF
+
+                R = Y10 + 1.140 * (V - 128.0)
+                G = Y10 - 0.395 * (U - 128.0) - 0.581 * (V - 128.0)
+                B = Y10 + 2.032 * (U - 128.0)
+                output_texture_data[(i + 1) * img_width * 4 + j * 4] = self._limit_rgb_value(R)
+                output_texture_data[(i + 1) * img_width * 4 + j * 4 + 1] = self._limit_rgb_value(G)
+                output_texture_data[(i + 1) * img_width * 4 + j * 4 + 2] = self._limit_rgb_value(B)
+                output_texture_data[(i + 1) * img_width * 4 + j * 4 + 3] = 0xFF
+
+                R = Y11 + 1.140 * (V - 128.0)
+                G = Y11 - 0.395 * (U - 128.0) - 0.581 * (V - 128.0)
+                B = Y11 + 2.032 * (U - 128.0)
+                output_texture_data[(i + 1) * img_width * 4 + j * 4 + 4] = self._limit_rgb_value(R)
+                output_texture_data[(i + 1) * img_width * 4 + j * 4 + 5] = self._limit_rgb_value(G)
+                output_texture_data[(i + 1) * img_width * 4 + j * 4 + 6] = self._limit_rgb_value(B)
+                output_texture_data[(i + 1) * img_width * 4 + j * 4 + 7] = 0xFF
+
+            p += 1
+
+        return output_texture_data
+
+    def _decode_yuv422_uyvy_image(self, image_data: bytes, img_width: int, img_height: int) -> bytes:
+        output_texture_data = bytearray(img_width * img_height * 4)
+
+        j: int = 0
+        for i in range(0, len(image_data), 4):
+            U = float(image_data[i])
+            Y0 = float(image_data[i + 1])
+            V = float(image_data[i + 2])
+            Y1 = float(image_data[i + 3])
+
+            R0 = Y0 + 1.140 * (V - 128.0)
+            G0 = Y0 - 0.395 * (U - 128.0) - 0.581 * (V - 128.0)
+            B0 = Y0 + 2.032 * (U - 128.0)
+
+            R1 = Y1 + 1.140 * (V - 128.0)
+            G1 = Y1 - 0.395 * (U - 128.0) - 0.581 * (V - 128.0)
+            B1 = Y1 + 2.032 * (U - 128.0)
+
+            output_texture_data[j] = self._limit_rgb_value(R0)
+            output_texture_data[j + 1] = self._limit_rgb_value(G0)
+            output_texture_data[j + 2] = self._limit_rgb_value(B0)
+            output_texture_data[j + 3] = 0xFF
+
+            output_texture_data[j + 4] = self._limit_rgb_value(R1)
+            output_texture_data[j + 5] = self._limit_rgb_value(G1)
+            output_texture_data[j + 6] = self._limit_rgb_value(B1)
+            output_texture_data[j + 7] = 0xFF
+
+            j += 8
+
+        return output_texture_data
+
+    def _decode_yuv444p_image(self, image_data: bytes, img_width: int, img_height: int) -> bytes:
+        output_texture_data = bytearray(img_width * img_height * 4)
+
+        num_pixels: int = img_width * img_height
+        y_plane_start: int = 0
+        u_plane_start: int = num_pixels
+        v_plane_start: int = num_pixels * 2
+
+        for i in range(img_height):
+            for j in range(img_width):
+                y_index = y_plane_start + i * img_width + j
+                u_index = u_plane_start + i * img_width + j
+                v_index = v_plane_start + i * img_width + j
+
+                Y = image_data[y_index]
+                U = image_data[u_index]
+                V = image_data[v_index]
+
+                R = Y + 1.140 * (V - 128)
+                G = Y - 0.395 * (U - 128) - 0.581 * (V - 128)
+                B = Y + 2.032 * (U - 128)
+
+                R = self._limit_rgb_value(R)
+                G = self._limit_rgb_value(G)
+                B = self._limit_rgb_value(B)
+
+                rgba_index = (i * img_width + j) * 4
+                output_texture_data[rgba_index] = R
+                output_texture_data[rgba_index + 1] = G
+                output_texture_data[rgba_index + 2] = B
+                output_texture_data[rgba_index + 3] = 0xFF
+
+        return output_texture_data
+
+    def _decode_yuv410p_image(self, image_data: bytes, img_width: int, img_height: int) -> bytes:
+        output_texture_data = bytearray(img_width * img_height * 4)
+        num_pixels: int = img_width * img_height
+        uv_width: int = img_width // 4
+        uv_height: int = img_height // 4
+        uv_size: int = uv_width * uv_height
+
+        y_plane_start: int = 0
+        u_plane_start: int = num_pixels
+        v_plane_start: int = num_pixels + uv_size
+
+        for i in range(img_height):
+            for j in range(img_width):
+                y_index = y_plane_start + i * img_width + j
+                u_index = u_plane_start + (i // 4) * uv_width + (j // 4)
+                v_index = v_plane_start + (i // 4) * uv_width + (j // 4)
+
+                Y = image_data[y_index]
+                U = image_data[u_index]
+                V = image_data[v_index]
+
+                R = Y + 1.140 * (V - 128)
+                G = Y - 0.395 * (U - 128) - 0.581 * (V - 128)
+                B = Y + 2.032 * (U - 128)
+
+                R = self._limit_rgb_value(R)
+                G = self._limit_rgb_value(G)
+                B = self._limit_rgb_value(B)
+
+                rgba_index = (i * img_width + j) * 4
+                output_texture_data[rgba_index] = R
+                output_texture_data[rgba_index + 1] = G
+                output_texture_data[rgba_index + 2] = B
+                output_texture_data[rgba_index + 3] = 0xFF
+
+        return output_texture_data
+
+    def _decode_yuv420p_image(self, image_data: bytes, img_width: int, img_height: int) -> bytes:
+        output_texture_data = bytearray(img_width * img_height * 4)
+        num_pixels: int = img_width * img_height
+        uv_width: int = img_width // 2
+        uv_height: int = img_height // 2
+        uv_size: int = uv_width * uv_height
+
+        y_plane_start: int = 0
+        u_plane_start: int = num_pixels
+        v_plane_start: int = num_pixels + uv_size
+
+        for i in range(img_height):
+            for j in range(img_width):
+                y_index = y_plane_start + i * img_width + j
+                u_index = u_plane_start + (i // 2) * uv_width + (j // 2)
+                v_index = v_plane_start + (i // 2) * uv_width + (j // 2)
+
+                Y = image_data[y_index]
+                U = image_data[u_index]
+                V = image_data[v_index]
+
+                R = Y + 1.140 * (V - 128)
+                G = Y - 0.395 * (U - 128) - 0.581 * (V - 128)
+                B = Y + 2.032 * (U - 128)
+
+                R = self._limit_rgb_value(R)
+                G = self._limit_rgb_value(G)
+                B = self._limit_rgb_value(B)
+
+                rgba_index = (i * img_width + j) * 4
+                output_texture_data[rgba_index] = R
+                output_texture_data[rgba_index + 1] = G
+                output_texture_data[rgba_index + 2] = B
+                output_texture_data[rgba_index + 3] = 0xFF
+
+        return output_texture_data
+
+    def _decode_yuv422p_image(self, image_data: bytes, img_width: int, img_height: int) -> bytes:
+        output_texture_data = bytearray(img_width * img_height * 4)
+        num_pixels: int = img_width * img_height
+        uv_width: int = img_width // 2
+        uv_size: int = uv_width * img_height
+
+        y_plane_start: int = 0
+        u_plane_start: int = num_pixels
+        v_plane_start: int = num_pixels + uv_size
+
+        for i in range(img_height):
+            for j in range(img_width):
+                y_index = y_plane_start + i * img_width + j
+                u_index = u_plane_start + i * uv_width + (j // 2)
+                v_index = v_plane_start + i * uv_width + (j // 2)
+
+                Y = image_data[y_index]
+                U = image_data[u_index]
+                V = image_data[v_index]
+
+                R = Y + 1.140 * (V - 128)
+                G = Y - 0.395 * (U - 128) - 0.581 * (V - 128)
+                B = Y + 2.032 * (U - 128)
+
+                R = self._limit_rgb_value(R)
+                G = self._limit_rgb_value(G)
+                B = self._limit_rgb_value(B)
+
+                rgba_index = (i * img_width + j) * 4
+                output_texture_data[rgba_index] = R
+                output_texture_data[rgba_index + 1] = G
+                output_texture_data[rgba_index + 2] = B
+                output_texture_data[rgba_index + 3] = 0xFF
+
+        return output_texture_data
+
+    def _decode_yuv411p_image(self, image_data: bytes, img_width: int, img_height: int) -> bytes:
+        output_texture_data = bytearray(img_width * img_height * 4)
+        num_pixels: int = img_width * img_height
+        uv_width: int = img_width // 4
+        uv_size: int = uv_width * img_height
+
+        y_plane_start: int = 0
+        u_plane_start: int = num_pixels
+        v_plane_start: int = num_pixels + uv_size
+
+        for i in range(img_height):
+            for j in range(img_width):
+                y_index = y_plane_start + i * img_width + j
+                u_index = u_plane_start + i * uv_width + (j // 4)
+                v_index = v_plane_start + i * uv_width + (j // 4)
+
+                Y = image_data[y_index]
+                U = image_data[u_index]
+                V = image_data[v_index]
+
+                R = Y + 1.140 * (V - 128)
+                G = Y - 0.395 * (U - 128) - 0.581 * (V - 128)
+                B = Y + 2.032 * (U - 128)
+
+                R = self._limit_rgb_value(R)
+                G = self._limit_rgb_value(G)
+                B = self._limit_rgb_value(B)
+
+                rgba_index = (i * img_width + j) * 4
+                output_texture_data[rgba_index] = R
+                output_texture_data[rgba_index + 1] = G
+                output_texture_data[rgba_index + 2] = B
+                output_texture_data[rgba_index + 3] = 0xFF
+
+        return output_texture_data
+
+    def _decode_yuv411_uyyvyy411_image(self, image_data: bytes, img_width: int, img_height: int) -> bytes:
+        output_texture_data = bytearray(img_width * img_height * 4)
+
+        def set_pixel(out_rgba_array, row, col, R, G, B):
+            out_index = (row * img_width + col) * 4
+            out_rgba_array[out_index] = R
+            out_rgba_array[out_index + 1] = G
+            out_rgba_array[out_index + 2] = B
+            out_rgba_array[out_index + 3] = 0xFF
+
+        for i in range(img_height):
+            for j in range(0, img_width, 4):
+                index: int = int(i * img_width * 1.5 + j * 1.5)
+
+                U = image_data[index]
+                Y0 = image_data[index + 1]
+                Y1 = image_data[index + 2]
+                V = image_data[index + 3]
+                Y2 = image_data[index + 4]
+                Y3 = image_data[index + 5]
+
+                R0, G0, B0 = self._yuv_to_rgb(Y0, U, V)
+                R1, G1, B1 = self._yuv_to_rgb(Y1, U, V)
+                R2, G2, B2 = self._yuv_to_rgb(Y2, U, V)
+                R3, G3, B3 = self._yuv_to_rgb(Y3, U, V)
+
+                set_pixel(output_texture_data, i, j, R0, G0, B0)
+                set_pixel(output_texture_data, i, j + 1, R1, G1, B1)
+                set_pixel(output_texture_data, i, j + 2, R2, G2, B2)
+                set_pixel(output_texture_data, i, j + 3, R3, G3, B3)
+
+        return output_texture_data
+
+    def _decode_yuv440p_image(self, image_data: bytes, img_width: int, img_height: int) -> bytes:
+        output_texture_data = bytearray(img_width * img_height * 4)
+        y_plane_size: int = img_width * img_height
+        uv_plane_size: int = img_width * (img_height // 2)
+
+        def set_pixel(out_rgba_array, row, col, R, G, B):
+            out_index = (row * img_width + col) * 4
+            out_rgba_array[out_index] = R
+            out_rgba_array[out_index + 1] = G
+            out_rgba_array[out_index + 2] = B
+            out_rgba_array[out_index + 3] = 0xFF
+
+        y_plane = image_data[0:y_plane_size]
+        u_plane = image_data[y_plane_size:y_plane_size + uv_plane_size]
+        v_plane = image_data[y_plane_size + uv_plane_size:y_plane_size + 2 * uv_plane_size]
+
+        for i in range(img_height):
+            for j in range(img_width):
+                Y = y_plane[i * img_width + j]
+                U = u_plane[(i // 2) * img_width + j]
+                V = v_plane[(i // 2) * img_width + j]
+
+                R, G, B = self._yuv_to_rgb(Y, U, V)
+                set_pixel(output_texture_data, i, j, R, G, B)
+
+        return output_texture_data
+
+    def _decode_yuva420p_image(self, image_data: bytes, img_width: int, img_height: int) -> bytes:
+        output_texture_data = bytearray(img_width * img_height * 4)
+        y_plane_size: int = img_width * img_height
+        uv_plane_size: int = (img_width // 2) * (img_height // 2)
+
+        def set_pixel(out_rgba_array, row, col, R, G, B, A):
+            out_index = (row * img_width + col) * 4
+            out_rgba_array[out_index] = R
+            out_rgba_array[out_index + 1] = G
+            out_rgba_array[out_index + 2] = B
+            out_rgba_array[out_index + 3] = A
+
+        y_plane = image_data[0:y_plane_size]
+        u_plane = image_data[y_plane_size:y_plane_size + uv_plane_size]
+        v_plane = image_data[y_plane_size + uv_plane_size:y_plane_size + 2 * uv_plane_size]
+        a_plane = image_data[y_plane_size + 2 * uv_plane_size:]
+
+        for i in range(img_height):
+            for j in range(img_width):
+                Y = y_plane[i * img_width + j]
+                U = u_plane[(i // 2) * (img_width // 2) + (j // 2)]
+                V = v_plane[(i // 2) * (img_width // 2) + (j // 2)]
+                A = a_plane[i * img_width + j]
+                R, G, B = self._yuv_to_rgb(Y, U, V)
+                set_pixel(output_texture_data, i, j, R, G, B, A)
+
+        return output_texture_data
+
+    def decode_yuv_image_main(self, image_data: bytes, img_width: int, img_height: int, image_format: ImageFormats) -> bytes:
+        self._check_if_yuv_image_dimensions_are_correct(img_width, img_height)
+
+        if image_format == ImageFormats.YUV422_YUY2:
+            return self._decode_yuv422_yuy2_image(image_data, img_width, img_height)
+        elif image_format == ImageFormats.YUV420_NV12:
+            return self._decode_yuv420_nv12_image(image_data, img_width, img_height)
+        elif image_format == ImageFormats.YUV420_NV21:
+            return self._decode_yuv420_nv21_image(image_data, img_width, img_height)
+        elif image_format == ImageFormats.YUV422_UYVY:
+            return self._decode_yuv422_uyvy_image(image_data, img_width, img_height)
+        elif image_format == ImageFormats.YUV444P:
+            return self._decode_yuv444p_image(image_data, img_width, img_height)
+        elif image_format == ImageFormats.YUV410P:
+            return self._decode_yuv410p_image(image_data, img_width, img_height)
+        elif image_format == ImageFormats.YUV420P:
+            return self._decode_yuv420p_image(image_data, img_width, img_height)
+        elif image_format == ImageFormats.YUV422P:
+            return self._decode_yuv422p_image(image_data, img_width, img_height)
+        elif image_format == ImageFormats.YUV411P:
+            return self._decode_yuv411p_image(image_data, img_width, img_height)
+        elif image_format == ImageFormats.YUV411_UYYVYY411:
+            return self._decode_yuv411_uyyvyy411_image(image_data, img_width, img_height)
+        elif image_format == ImageFormats.YUV440P:
+            return self._decode_yuv440p_image(image_data, img_width, img_height)
+        elif image_format == ImageFormats.YUVA420P:
+            return self._decode_yuva420p_image(image_data, img_width, img_height)
+        else:
+            raise Exception(f"Image format not supported by yuv decoder! Image_format: {image_format}")

{ReverseBox-0.18.2 → ReverseBox-0.18.4}/reversebox/image/swizzling/swizzle_ps2.py

@@ -130,7 +130,7 @@ def _convert_ps2_16bit(image_data: bytes, width: int, height: int, swizzle_flag:
     return converted_data
 
 
-# special 4-bit swizzle/unswizzle function used in SSH files from EA PS2 games
+# special "type 3" 4-bit swizzle/unswizzle function used in SSH files from EA PS2 games
 def _convert_ps2_ea_4bit(image_data: bytes, img_width: int, img_height: int, bpp: int, swizzle_flag: bool) -> bytes:
     if bpp != 4:
         raise Exception(f"Not supported bpp={bpp} for EA swizzle!")
@@ -140,11 +140,11 @@ def _convert_ps2_ea_4bit(image_data: bytes, img_width: int, img_height: int, bpp
 
     try:
         ea_swizzle_dll_path: str = get_dll_path("ea_swizzle.dll")
-        refpack_dll_file = ctypes.CDLL(ea_swizzle_dll_path)
+        ea_swizzle_dll_file = ctypes.CDLL(ea_swizzle_dll_path)
         if not swizzle_flag:
-            refpack_dll_file.unswizzle4(image_data, byref(converted_data_buffer), img_width, img_height)
+            ea_swizzle_dll_file.unswizzle4(image_data, byref(converted_data_buffer), img_width, img_height)
         else:
-            refpack_dll_file.swizzle4(image_data, byref(converted_data_buffer), img_width, img_height)
+            ea_swizzle_dll_file.swizzle4(image_data, byref(converted_data_buffer), img_width, img_height)
     except Exception as error:
         raise Exception(f"Error while unswizzling data! Error: {error}")
 

{ReverseBox-0.18.2 → ReverseBox-0.18.4}/setup.py

@@ -7,7 +7,7 @@ import os
 
 import setuptools
 
-VERSION_NUM = "0.18.2"
+VERSION_NUM = "0.18.4"
 
 
 def get_long_description() -> str:

ReverseBox-0.18.2/reversebox/compression/compression_refpack.py

@@ -1,55 +0,0 @@
-"""
-Copyright © 2024  Bartłomiej Duda
-License: GPL-3.0 License
-"""
-import ctypes
-from ctypes import byref, c_char
-
-from reversebox.common.common import get_dll_path
-
-
-class RefpackHandler:
-    def compress_data(self, input_data: bytes) -> bytes:
-        return input_data  # TODO - fix this
-
-    def _get_output_buffer_size(self, compressed_data: bytes) -> int:
-        current_input_offset: int = 0
-        compression_type = compressed_data[current_input_offset]
-        current_input_offset += 1
-        compression_type = (compression_type << 8) + compressed_data[
-            current_input_offset
-        ]
-        current_input_offset += 1
-
-        if compression_type & 0x100:
-            current_input_offset += 3  # skip uncompressed_size
-
-        uncompressed_size: int = compressed_data[current_input_offset]
-        current_input_offset += 1
-        uncompressed_size = (uncompressed_size << 8) + compressed_data[
-            current_input_offset
-        ]
-        current_input_offset += 1
-        uncompressed_size = (uncompressed_size << 8) + compressed_data[
-            current_input_offset
-        ]
-        current_input_offset += 1
-        return uncompressed_size
-
-    def decompress_data(self, compressed_data: bytes) -> bytes:
-        if len(compressed_data) < 5:
-            raise Exception("Compressed data too short!")
-        if compressed_data[:2] != b"\x10\xFB":
-            raise Exception("Wrong refpack compression header!")
-        uncompressed_data_buffer = (
-            c_char * self._get_output_buffer_size(compressed_data)
-        )()
-        try:
-            refpack_dll_path: str = get_dll_path("refpack.dll")
-            refpack_dll_file = ctypes.CDLL(refpack_dll_path)
-            uncompressed_data_size = refpack_dll_file.unrefpack(
-                compressed_data, byref(uncompressed_data_buffer), 1
-            )
-        except Exception as error:
-            raise Exception(f"Error while decompressing refpack data! Error: {error}")
-        return bytes(bytearray(uncompressed_data_buffer)[:uncompressed_data_size])