When working with non-squared non-power of two textures check this divisions

[github-actions[bot]]

https://github.com/space928/Blender-O3D-IO-Public/blob/dd30231969ecf0acde33fa9f8598e22e364e5daa/o3d_io/dds_loader/dds_loader.py#L355

"""
Copyright (c) 2015 Edoardo "sparkon" Dominici

Permission is hereby granted, free of charge, to any person
obtaining a copy of this software and associated documentation
files (the "Software"), to deal in the Software without
restriction, including without limitation the rights to use,
copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the
Software is furnished to do so, subject to the following
conditions:

The above copyright notice and this permission notice shall be
included in all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
OTHER DEALINGS IN THE SOFTWARE.
"""

import ctypes
import os

from . import dxgi_values


def log(*args):
    print("[DDS_Loader] ", *args)

# Win32 following : https://msdn.microsoft.com/en-us/library/windows/desktop/aa383751(v=vs.85).aspx
class Win32Types:
    DWORD = ctypes.c_ulong
    UINT = ctypes.c_uint


# DDS types
DDSEnumType = ctypes.c_ulong
DDSMagicNumber = Win32Types.DWORD
DDSFormatCC = Win32Types.DWORD


# Contains all default values used for validation
class DDSValues:
    MIN_FILE_SIZE = 128
    MAGIC_NUMBER = 0x20534444

    HEADER_SIZE = 124
    PIXELFORMAT_SIZE = 32


# Values used for flagging
class DDSEnums:
    # Complexity of stores resources DDS_HEADER::dwCaps
    DDSCAPS_COMPLEX = 0x8
    DDSCAPS_MIPMAP = 0x400000
    DDSCAPS_TEXTURE = 0x1000

    # Additional detail on surface DDS_HEADER::dwCaps2
    DDSCAPS2_CUBEMAP = 0x200
    DDSCAPS2_VOLUME = 0x200000

    # Flags to indicate what is stored inside the texture, they
    # are ignored for the most part since pitch and size are
    # calculated manually, they are used for structure validation
    DDSD_CAPS = 0x1
    DDSD_HEIGHT = 0x2
    DDSD_WIDTH = 0x4
    DDSD_PITCH = 0x8
    DDSD_PIXELFORMAT = 0x1000
    DDSD_MIPMAPCOUNT = 0x20000
    DDSD_LINEARSIZE = 0x80000
    DDSD_DEPTH = 0x800000

    # Only flag we are interested in DDS_PIXELFORMAT::dwFlags, is needed
    # to make sure the extended header is included
    DDPF_FOURCC = 0x4

    # Only value we are interested in DDS_PIXELFORMAT::dwFourCC, is needed
    # to make sure the extended header is included
    DX10_CC = int.from_bytes(bytearray(b"DX10"), byteorder="little", signed="false")

    # Misc flag in the DDS_HEADER_DXT10, flags the resource as cubemap
    DDS_RESOURCE_MISC_TEXTURECUBE = 0x4


# 1-to-1 mapping of DDS_PIXELFORMAT https://msdn.microsoft.com/en-us/library/windows/desktop/bb943984(v=vs.85).aspx
class DDSPixelFormat(ctypes.Structure):
    _fields_ = [
        ("dwSize", Win32Types.DWORD),
        ("dwFlags", Win32Types.DWORD),
        ("dwFourCC", DDSFormatCC),
        ("dwRGBBitCount", Win32Types.DWORD),
        ("dwRBitMask", Win32Types.DWORD),
        ("dwGBitMask", Win32Types.DWORD),
        ("dwBBitMask", Win32Types.DWORD),
        ("dwABitMask", Win32Types.DWORD)
    ]


# 1-to-1 mapping of DDS_HEADER https://msdn.microsoft.com/en-us/library/windows/desktop/bb943982(v=vs.85).aspx
class DDSHeader(ctypes.Structure):
    _fields_ = [
        ("dwSize", Win32Types.DWORD),
        ("dwFlags", Win32Types.DWORD),
        ("dwHeight", Win32Types.DWORD),
        ("dwWidth", Win32Types.DWORD),
        ("dwPitchOrLinearSize", Win32Types.DWORD),
        ("dwDepth", Win32Types.DWORD),
        ("dwMipMapCount", Win32Types.DWORD),
        ("dwReserved", Win32Types.DWORD * 11),
        ("ddspf", DDSPixelFormat),
        ("dwCaps", Win32Types.DWORD),
        ("dwCaps2", Win32Types.DWORD),
        ("dwCaps3", Win32Types.DWORD),
        ("dwCaps4", Win32Types.DWORD),
        ("dwReserved2", Win32Types.DWORD)
    ]


# 1-to-1 mapping of DDS_HEADER_DXT10 https://msdn.microsoft.com/en-us/library/windows/desktop/bb943983(v=vs.85).aspx
class DDSExtHeader(ctypes.Structure):
    _fields_ = [
        ("dxgiFormat", DDSEnumType),
        ("resourceDimension", DDSEnumType),
        ("miscFlag", Win32Types.UINT),
        ("arraySize", Win32Types.UINT),
        ("miscFlags2", Win32Types.UINT)
    ]


# FormatNotValid is raised when the file provided is not valid, more information in the message
class FormatNotValid(Exception):
    pass


# FormatNotSupported is raised when the file has some feature that is not supported by this implementation
class FormatNotSupported(Exception):
    pass


# Represents a single surface of any kind, depending on its position and the DDSTexture info the
# miplevel or array index can be deduced
class DDSSurface:
    def __init__(self, width, height, pitch, size, data):
        self.width = width
        self.height = height
        self.pitch = pitch
        self.size = size
        self.data = data

    def __str__(self):
        return "Width: {0} Height: {1} Pitch: {2} Size: {3}".format(self.width, self.height, self.pitch, self.size)


# Represents a loaded DDSFile, the name might be misleading since multiple textures or texturecubes can be
# contained inside here
class DDSTexture:
    # Type of the DDSTexture, volume texture is not supported, and 1D textures should be mapped
    # to 2D textures with height == 1, but this hasn't been tested yet ( TODO )
    class Type:
        Texture2D = 0
        TextureCube = 1
        Texture2DArray = 2
        TextureCubeArray = 3

        names = [
            "Texture2D",
            "TextureCube",
            "Texture2DArray",
            "TextureCubeArray"
        ]

    def __init__(self):
        self.real_size = 0
        self.calculated_size = 0

        # File format
        self.name = None
        self.magic_number = DDSMagicNumber()
        self.header = DDSHeader()
        self.ext_header = DDSExtHeader()

        # Type information
        self.type = None
        self.array_size = None

        # List of surfaces that contain info on how to read raw data
        self.surfaces = []

        # Raw data
        self.data = None

        # Format information
        self.dxgi_format = None
        self.is_compressed = None
        self.bpp_or_block_size = None
        self.mipmap_count = None
        self.format_code = self.header.ddspf.dwFourCC

    def __str__(self):
        return "{0} | Type={1} ArraySize={2} MipMapCount={3} Format={4} BPP={5}".format(self.name,
                                                                                        self.Type.names[self.type],
                                                                                        self.array_size,
                                                                                        self.mipmap_count,
                                                                                        self.dxgi_format,
                                                                                        self.bpp_or_block_size)

    # Used internally to validate information contained inside the headers to make sure reading
    # or writing was successful. This test could be removed, but files that do not pass this *NOT COMPLETE*
    # validation phase are not following the specification
    def _validate_structures(self):
        if self.header.dwSize != DDSValues.HEADER_SIZE:
            raise FormatNotValid("File not formatted correctly, header size not matching")

        if self.header.ddspf.dwSize != DDSValues.PIXELFORMAT_SIZE:
            raise FormatNotValid("File not formatted correctly, extended header size not matching")

        if not (self.header.dwFlags & DDSEnums.DDSD_CAPS) or \
                not (self.header.dwFlags & DDSEnums.DDSD_WIDTH) or \
                not (self.header.dwFlags & DDSEnums.DDSD_HEIGHT) or \
                not (self.header.dwFlags & DDSEnums.DDSD_PIXELFORMAT) or \
                not (self.header.dwFlags & DDSEnums.DDSD_CAPS) or \
                not (self.header.dwFlags & DDSEnums.DDSD_CAPS):
            raise FormatNotValid("File not formatted correctly, required flags not present")

        if not (self.header.dwCaps & DDSEnums.DDSCAPS_TEXTURE):
            raise FormatNotValid("File not formatted correctly, required flags not present")

    # Fills in information regarding the pixel format
    def _compute_format(self):
        if self.format_code != DDSEnums.DX10_CC:
            # <DX10 DDS file, try to infer the format
            pf = self.header.ddspf
            try:
                if pf.dwFlags & DDSEnums.DDPF_FOURCC:
                    self.dxgi_format = dxgi_values.four_cc_to_dxgi[pf.dwFourCC]
                else:
                    self.dxgi_format = dxgi_values.format_to_dxgi[(pf.dwFlags, pf.dwRGBBitCount, pf.dwRBitMask,
                                                                   pf.dwGBitMask, pf.dwBBitMask, pf.dwABitMask)]
            except KeyError:
                # For very wierd dds formats which we don't support
                self.dxgi_format = -1
        else:
            self.dxgi_format = self.ext_header.dxgiFormat

        # If the texture is compressed
        self.bpp_or_block_size = dxgi_values.dxgi_pixel_or_block_size[self.dxgi_format]

        # Checking if the texture is compressed or not ( we need it to calculate pitch )
        self.is_compressed = self.dxgi_format in dxgi_values.dxgi_compressed_formats

        # Checking if there are mipmaps
        self.mipmap_count = max(self.header.dwMipMapCount, 1)

    # Computes the type of the DDSTexture
    def _compute_type(self):
        if not (self.header.dwCaps & DDSEnums.DDSCAPS_TEXTURE):
            raise FormatNotValid("Invalid format file not tagged as texture")

        if self.header.dwCaps2 & DDSEnums.DDSCAPS2_CUBEMAP:
            if self.ext_header.arraySize > 1:
                self.type = DDSTexture.Type.TextureCubeArray
                self.array_size = self.ext_header.arraySize
            else:
                self.type = DDSTexture.Type.TextureCube
                self.array_size = 1
        # We either have a single texture or a texture array ( 2D )
        else:
            if self.format_code == DDSEnums.DX10_CC and \
                    self.ext_header.arraySize > 1:
                self.type = DDSTexture.Type.Texture2DArray
                self.array_size = self.ext_header.arraySize
            else:
                self.type = DDSTexture.Type.Texture2D
                self.array_size = 1

    # Loads the texture from the filename, obtaining data - array of c_byte containing untouched texture data
    # formatted matching the surfaces data surfaces - metadata for the raw texture data that describes how it can be
    # read, its valued are ready for DirectX11 creation ( Pitch, width, height, size ) format - DXGI compatible format
    # the integer self.format can be safely static_cast<DXGI_FORMAT> to obtain the C++ enumerator counterpart
    def load(self, filename):
        self.name = filename

        # Making sure the file is big enough to contain the magic number + default header
        self.real_size = os.path.getsize(filename)
        if self.real_size < DDSValues.MIN_FILE_SIZE:
            raise FormatNotValid("File is too small")

        with open(filename, "rb") as file_stream:
            # Reading magic number and making sure is valid
            bytes_read = file_stream.readinto(self.magic_number)
            if bytes_read < ctypes.sizeof(self.magic_number):
                raise FormatNotValid("Failed to read magic number")

            if self.magic_number.value != DDSValues.MAGIC_NUMBER:
                raise FormatNotValid("Invalid magic number")

            # Reading header
            bytes_read = file_stream.readinto(self.header)
            if bytes_read < ctypes.sizeof(self.header):
                raise FormatNotValid("Failed to read header")

            # Reading extended header
            if self.header.ddspf.dwFlags & DDSEnums.DDPF_FOURCC and self.header.ddspf.dwFourCC == DDSEnums.DX10_CC:
                bytes_read = file_stream.readinto(self.ext_header)
                if bytes_read < ctypes.sizeof(self.ext_header):
                    raise FormatNotValid("Failed to read extended header")
            # else:
            #     raise FormatNotSupported(
            #         "Sorry we only support DDS texture with DX10 extended header, if you are using texconv tools use "
            #         "the -dx10 flag")

            # Validating the DDS_HEADER and DX10_DDS_HEADER to make sure they comply to specification
            # or supported features
            self._validate_structures()

            # Calculates the compression / format and bpp
            self._compute_format()
            # Computes the type of this DDSTexture instance
            self._compute_type()

            total_data_size = 0
            total_bytes_read = 0

            # Looping through all the textures and saving surface data
            elements = self.array_size
            if self.type == self.Type.TextureCube or self.type == self.Type.TextureCubeArray:
                elements *= 6

            for i in range(elements):
                next_width = self.header.dwWidth
                next_height = self.header.dwHeight
                if self.is_compressed:
                    next_size = self.header.dwPitchOrLinearSize
                else:
                    next_size = next_height * next_width * self.header.ddspf.dwRGBBitCount // 8

                for mipmap in range(self.mipmap_count):
                    total_data_size += next_size
                    if self.is_compressed:
                        pitch = max(1, int(((next_width + 3) / 4))) * self.bpp_or_block_size
                    else:
                        pitch = (next_width * self.bpp_or_block_size + 7) / 8

                    # Read surface data
                    data = (ctypes.c_byte * next_size)()
                    total_bytes_read += file_stream.readinto(data)

                    self.surfaces.append(DDSSurface(next_width, next_height, pitch, next_size, data))
                    # TODO When working with non-squared non-power of two textures check this divisions
                    next_width = int(next_width / 2)
                    next_height = int(next_height / 2)
                    next_size = max(8, int(next_size / 4))

            if total_bytes_read < total_data_size:
                log("WARNING: Invalid DDS file loaded! Not enough data in file for specified format! Read {0} bytes, "
                    "expected {1}. Path: {2} format: {3}".format(total_bytes_read, total_data_size, filename,
                                                                 self.dxgi_format))
                # raise FormatNotValid("Metadata doesn't match actual data")