Add files using upload-large-folder tool

ee1cef6 verified 11 days ago

8.31 kB

/* -*- tab-width: 4; -*- */
/* vi: set sw=2 ts=4 expandtab: */

/* $Id$ */

/*
 * Copyright 2010-2020 The Khronos Group Inc.
 * SPDX-License-Identifier: Apache-2.0
 */

/**
 * @internal
 * @file
 * @~English
 *
 * @brief Function to verify a KTX file header
 *
 * @author Mark Callow, HI Corporation
 */

/*
 * Author: Georg Kolling, Imagination Technology with modifications
 * by Mark Callow, HI Corporation.
 */
#include <assert.h>
#include <string.h>

#include "ktx.h"
#include "ktxint.h"
#include "vkformat_enum.h"

bool isProhibitedFormat(VkFormat format);
bool isValidFormat(VkFormat format);

/**
 * @internal
 * @~English
 * @brief Check a KTX file header.
 *
 * As well as checking that the header identifies a KTX file, the function
 * sanity checks the values and returns information about the texture in a
 * struct KTX_supplementary_info.
 *
 * @param pHeader   pointer to the KTX header to check
 * @param pSuppInfo pointer to a KTX_supplementary_info structure in which to
 *                  return information about the texture.
 *
 * @author Georg Kolling, Imagination Technology
 * @author Mark Callow, HI Corporation
 */

KTX_error_code  ktxCheckHeader1_(KTX_header* pHeader,
                                 KTX_supplemental_info* pSuppInfo)
{
    ktx_uint8_t identifier_reference[12] = KTX_IDENTIFIER_REF;
    ktx_uint32_t max_dim;

    assert(pHeader != NULL && pSuppInfo != NULL);

    /* Compare identifier, is this a KTX file? */
    if (memcmp(pHeader->identifier, identifier_reference, 12) != 0)
    {
        return KTX_UNKNOWN_FILE_FORMAT;
    }

    if (pHeader->endianness == KTX_ENDIAN_REF_REV)
    {
        /* Convert endianness of pHeader fields. */
        _ktxSwapEndian32(&pHeader->glType, 12);

        if (pHeader->glTypeSize != 1 &&
            pHeader->glTypeSize != 2 &&
            pHeader->glTypeSize != 4)
        {
            /* Only 8-, 16-, and 32-bit types supported so far. */
            return KTX_FILE_DATA_ERROR;
        }
    }
    else if (pHeader->endianness != KTX_ENDIAN_REF)
    {
        return KTX_FILE_DATA_ERROR;
    }

    /* Check glType and glFormat */
    pSuppInfo->compressed = 0;
    if (pHeader->glType == 0 || pHeader->glFormat == 0)
    {
        if (pHeader->glType + pHeader->glFormat != 0)
        {
            /* either both or none of glType, glFormat must be zero */
            return KTX_FILE_DATA_ERROR;
        }
        pSuppInfo->compressed = 1;
    }

    if (pHeader->glFormat == pHeader->glInternalformat) {
        // glInternalFormat is either unsized (which is no longer and should
        // never have been supported by libktx) or glFormat is sized.
        return KTX_FILE_DATA_ERROR;
    }

    /* Check texture dimensions. KTX files can store 8 types of textures:
       1D, 2D, 3D, cube, and array variants of these. There is currently
       no GL extension for 3D array textures. */
    if ((pHeader->pixelWidth == 0) ||
        (pHeader->pixelDepth > 0 && pHeader->pixelHeight == 0))
    {
        /* texture must have width */
        /* texture must have height if it has depth */
        return KTX_FILE_DATA_ERROR;
    }


    if (pHeader->pixelDepth > 0)
    {
        if (pHeader->numberOfArrayElements > 0)
        {
            /* No 3D array textures yet. */
            return KTX_UNSUPPORTED_FEATURE;
        }
        pSuppInfo->textureDimension = 3;
    }
    else if (pHeader->pixelHeight > 0)
    {
        pSuppInfo->textureDimension = 2;
    }
    else
    {
        pSuppInfo->textureDimension = 1;
    }

    if (pHeader->numberOfFaces == 6)
    {
        if (pSuppInfo->textureDimension != 2)
        {
            /* cube map needs 2D faces */
            return KTX_FILE_DATA_ERROR;
        }
    }
    else if (pHeader->numberOfFaces != 1)
    {
        /* numberOfFaces must be either 1 or 6 */
        return KTX_FILE_DATA_ERROR;
    }

    /* Check number of mipmap levels */
    if (pHeader->numberOfMipLevels == 0)
    {
        pSuppInfo->generateMipmaps = 1;
        pHeader->numberOfMipLevels = 1;
    }
    else
    {
        pSuppInfo->generateMipmaps = 0;
    }

    /* This test works for arrays too because height or depth will be 0. */
    max_dim = MAX(MAX(pHeader->pixelWidth, pHeader->pixelHeight), pHeader->pixelDepth);
    if (max_dim < ((ktx_uint32_t)1 << (pHeader->numberOfMipLevels - 1)))
    {
        /* Can't have more mip levels than 1 + log2(max(width, height, depth)) */
        return KTX_FILE_DATA_ERROR;
    }

    return KTX_SUCCESS;
}

/**
 * @internal
 * @~English
 * @brief Check a KTX2 file header.
 *
 * As well as checking that the header identifies a KTX 2 file, the function
 * sanity checks the values and returns information about the texture in a
 * struct KTX_supplementary_info.
 *
 * @param pHeader   pointer to the KTX header to check
 * @param pSuppInfo pointer to a KTX_supplementary_info structure in which to
 *                  return information about the texture.
 *
 * @author Mark Callow, HI Corporation
 */
KTX_error_code ktxCheckHeader2_(KTX_header2* pHeader,
                                KTX_supplemental_info* pSuppInfo)
{
// supp info is compressed, generateMipmaps and num dimensions. Don't need
// compressed as formatSize gives us that. I think the other 2 aren't needed.
    ktx_uint8_t identifier_reference[12] = KTX2_IDENTIFIER_REF;

    assert(pHeader != NULL && pSuppInfo != NULL);
    ktx_uint32_t max_dim;

    /* Compare identifier, is this a KTX file? */
    if (memcmp(pHeader->identifier, identifier_reference, 12) != 0)
    {
        return KTX_UNKNOWN_FILE_FORMAT;
    }

    /* Check format */
    if (isProhibitedFormat(pHeader->vkFormat))
    {
        return KTX_FILE_DATA_ERROR;
    }
    if (!isValidFormat(pHeader->vkFormat))
    {
        return KTX_UNSUPPORTED_FEATURE;
    }
    if (pHeader->supercompressionScheme == KTX_SS_BASIS_LZ && pHeader->vkFormat != VK_FORMAT_UNDEFINED)
    {
        return KTX_FILE_DATA_ERROR;
    }

    /* Check texture dimensions. KTX files can store 8 types of textures:
       1D, 2D, 3D, cube, and array variants of these. There is currently
       no extension for 3D array textures in any 3D API. */
    if ((pHeader->pixelWidth == 0) ||
        (pHeader->pixelDepth > 0 && pHeader->pixelHeight == 0))
    {
        /* texture must have width */
        /* texture must have height if it has depth */
        return KTX_FILE_DATA_ERROR;
    }

    if (pHeader->pixelDepth > 0)
    {
        if (pHeader->layerCount > 0)
        {
            /* No 3D array textures yet. */
            return KTX_UNSUPPORTED_FEATURE;
        }
        pSuppInfo->textureDimension = 3;
    }
    else if (pHeader->pixelHeight > 0)
    {
        pSuppInfo->textureDimension = 2;
    }
    else
    {
        pSuppInfo->textureDimension = 1;
    }

    if (pHeader->faceCount == 6)
    {
        if (pSuppInfo->textureDimension != 2)
        {
            /* cube map needs 2D faces */
            return KTX_FILE_DATA_ERROR;
        }
        if (pHeader->pixelDepth != 0)
        {
            /* cube map cannot have depth */
            return KTX_FILE_DATA_ERROR;
        }
        if (pHeader->pixelWidth != pHeader->pixelHeight)
        {
            /* cube map needs square faces */
            return KTX_FILE_DATA_ERROR;
        }
    }
    else if (pHeader->faceCount != 1)
    {
        /* numberOfFaces must be either 1 or 6 */
        return KTX_FILE_DATA_ERROR;
    }

    // Check number of mipmap levels
    if (pHeader->levelCount == 0)
    {
        pSuppInfo->generateMipmaps = 1;
        pHeader->levelCount = 1;
    }
    else
    {
        pSuppInfo->generateMipmaps = 0;
    }

    // Check supercompression
    switch (pHeader->supercompressionScheme) {
      case KTX_SS_NONE:
      case KTX_SS_BASIS_LZ:
      case KTX_SS_ZSTD:
      case KTX_SS_ZLIB:
        break;
      default:
        // Unsupported supercompression
        return KTX_UNSUPPORTED_FEATURE;
    }

    // This test works for arrays too because height or depth will be 0.
    max_dim = MAX(MAX(pHeader->pixelWidth, pHeader->pixelHeight), pHeader->pixelDepth);
    if (max_dim < ((ktx_uint32_t)1 << (pHeader->levelCount - 1)))
    {
        // Can't have more mip levels than 1 + log2(max(width, height, depth))
        return KTX_FILE_DATA_ERROR;
    }

    return KTX_SUCCESS;

}

	/* -- tab-width: 4; -- */
	/* vi: set sw=2 ts=4 expandtab: */

	/* $Id$ */

	/*
	* Copyright 2010-2020 The Khronos Group Inc.
	* SPDX-License-Identifier: Apache-2.0
	*/

	/**
	* @internal
	* @file
	* @~English
	*
	* @brief Function to verify a KTX file header
	*
	* @author Mark Callow, HI Corporation
	*/

	/*
	* Author: Georg Kolling, Imagination Technology with modifications
	* by Mark Callow, HI Corporation.
	*/
	#include <assert.h>
	#include <string.h>

	#include "ktx.h"
	#include "ktxint.h"
	#include "vkformat_enum.h"

	bool isProhibitedFormat(VkFormat format);
	bool isValidFormat(VkFormat format);

	/**
	* @internal
	* @~English
	* @brief Check a KTX file header.
	*
	* As well as checking that the header identifies a KTX file, the function
	* sanity checks the values and returns information about the texture in a
	* struct KTX_supplementary_info.
	*
	* @param pHeader pointer to the KTX header to check
	* @param pSuppInfo pointer to a KTX_supplementary_info structure in which to
	* return information about the texture.
	*
	* @author Georg Kolling, Imagination Technology
	* @author Mark Callow, HI Corporation
	*/

	KTX_error_code ktxCheckHeader1_(KTX_header* pHeader,
	KTX_supplemental_info* pSuppInfo)
	{
	ktx_uint8_t identifier_reference[12] = KTX_IDENTIFIER_REF;
	ktx_uint32_t max_dim;

	assert(pHeader != NULL && pSuppInfo != NULL);

	/* Compare identifier, is this a KTX file? */
	if (memcmp(pHeader->identifier, identifier_reference, 12) != 0)
	{
	return KTX_UNKNOWN_FILE_FORMAT;
	}

	if (pHeader->endianness == KTX_ENDIAN_REF_REV)
	{
	/* Convert endianness of pHeader fields. */
	_ktxSwapEndian32(&pHeader->glType, 12);

	if (pHeader->glTypeSize != 1 &&
	pHeader->glTypeSize != 2 &&
	pHeader->glTypeSize != 4)
	{
	/* Only 8-, 16-, and 32-bit types supported so far. */
	return KTX_FILE_DATA_ERROR;
	}
	}
	else if (pHeader->endianness != KTX_ENDIAN_REF)
	{
	return KTX_FILE_DATA_ERROR;
	}

	/* Check glType and glFormat */
	pSuppInfo->compressed = 0;
	if (pHeader->glType == 0 \|\| pHeader->glFormat == 0)
	{
	if (pHeader->glType + pHeader->glFormat != 0)
	{
	/* either both or none of glType, glFormat must be zero */
	return KTX_FILE_DATA_ERROR;
	}
	pSuppInfo->compressed = 1;
	}

	if (pHeader->glFormat == pHeader->glInternalformat) {
	// glInternalFormat is either unsized (which is no longer and should
	// never have been supported by libktx) or glFormat is sized.
	return KTX_FILE_DATA_ERROR;
	}

	/* Check texture dimensions. KTX files can store 8 types of textures:
	1D, 2D, 3D, cube, and array variants of these. There is currently
	no GL extension for 3D array textures. */
	if ((pHeader->pixelWidth == 0) \|\|
	(pHeader->pixelDepth > 0 && pHeader->pixelHeight == 0))
	{
	/* texture must have width */
	/* texture must have height if it has depth */
	return KTX_FILE_DATA_ERROR;
	}


	if (pHeader->pixelDepth > 0)
	{
	if (pHeader->numberOfArrayElements > 0)
	{
	/* No 3D array textures yet. */
	return KTX_UNSUPPORTED_FEATURE;
	}
	pSuppInfo->textureDimension = 3;
	}
	else if (pHeader->pixelHeight > 0)
	{
	pSuppInfo->textureDimension = 2;
	}
	else
	{
	pSuppInfo->textureDimension = 1;
	}

	if (pHeader->numberOfFaces == 6)
	{
	if (pSuppInfo->textureDimension != 2)
	{
	/* cube map needs 2D faces */
	return KTX_FILE_DATA_ERROR;
	}
	}
	else if (pHeader->numberOfFaces != 1)
	{
	/* numberOfFaces must be either 1 or 6 */
	return KTX_FILE_DATA_ERROR;
	}

	/* Check number of mipmap levels */
	if (pHeader->numberOfMipLevels == 0)
	{
	pSuppInfo->generateMipmaps = 1;
	pHeader->numberOfMipLevels = 1;
	}
	else
	{
	pSuppInfo->generateMipmaps = 0;
	}

	/* This test works for arrays too because height or depth will be 0. */
	max_dim = MAX(MAX(pHeader->pixelWidth, pHeader->pixelHeight), pHeader->pixelDepth);
	if (max_dim < ((ktx_uint32_t)1 << (pHeader->numberOfMipLevels - 1)))
	{
	/* Can't have more mip levels than 1 + log2(max(width, height, depth)) */
	return KTX_FILE_DATA_ERROR;
	}

	return KTX_SUCCESS;
	}

	/**
	* @internal
	* @~English
	* @brief Check a KTX2 file header.
	*
	* As well as checking that the header identifies a KTX 2 file, the function
	* sanity checks the values and returns information about the texture in a
	* struct KTX_supplementary_info.
	*
	* @param pHeader pointer to the KTX header to check
	* @param pSuppInfo pointer to a KTX_supplementary_info structure in which to
	* return information about the texture.
	*
	* @author Mark Callow, HI Corporation
	*/
	KTX_error_code ktxCheckHeader2_(KTX_header2* pHeader,
	KTX_supplemental_info* pSuppInfo)
	{
	// supp info is compressed, generateMipmaps and num dimensions. Don't need
	// compressed as formatSize gives us that. I think the other 2 aren't needed.
	ktx_uint8_t identifier_reference[12] = KTX2_IDENTIFIER_REF;

	assert(pHeader != NULL && pSuppInfo != NULL);
	ktx_uint32_t max_dim;

	/* Compare identifier, is this a KTX file? */
	if (memcmp(pHeader->identifier, identifier_reference, 12) != 0)
	{
	return KTX_UNKNOWN_FILE_FORMAT;
	}

	/* Check format */
	if (isProhibitedFormat(pHeader->vkFormat))
	{
	return KTX_FILE_DATA_ERROR;
	}
	if (!isValidFormat(pHeader->vkFormat))
	{
	return KTX_UNSUPPORTED_FEATURE;
	}
	if (pHeader->supercompressionScheme == KTX_SS_BASIS_LZ && pHeader->vkFormat != VK_FORMAT_UNDEFINED)
	{
	return KTX_FILE_DATA_ERROR;
	}

	/* Check texture dimensions. KTX files can store 8 types of textures:
	1D, 2D, 3D, cube, and array variants of these. There is currently
	no extension for 3D array textures in any 3D API. */
	if ((pHeader->pixelWidth == 0) \|\|
	(pHeader->pixelDepth > 0 && pHeader->pixelHeight == 0))
	{
	/* texture must have width */
	/* texture must have height if it has depth */
	return KTX_FILE_DATA_ERROR;
	}

	if (pHeader->pixelDepth > 0)
	{
	if (pHeader->layerCount > 0)
	{
	/* No 3D array textures yet. */
	return KTX_UNSUPPORTED_FEATURE;
	}
	pSuppInfo->textureDimension = 3;
	}
	else if (pHeader->pixelHeight > 0)
	{
	pSuppInfo->textureDimension = 2;
	}
	else
	{
	pSuppInfo->textureDimension = 1;
	}

	if (pHeader->faceCount == 6)
	{
	if (pSuppInfo->textureDimension != 2)
	{
	/* cube map needs 2D faces */
	return KTX_FILE_DATA_ERROR;
	}
	if (pHeader->pixelDepth != 0)
	{
	/* cube map cannot have depth */
	return KTX_FILE_DATA_ERROR;
	}
	if (pHeader->pixelWidth != pHeader->pixelHeight)
	{
	/* cube map needs square faces */
	return KTX_FILE_DATA_ERROR;
	}
	}
	else if (pHeader->faceCount != 1)
	{
	/* numberOfFaces must be either 1 or 6 */
	return KTX_FILE_DATA_ERROR;
	}

	// Check number of mipmap levels
	if (pHeader->levelCount == 0)
	{
	pSuppInfo->generateMipmaps = 1;
	pHeader->levelCount = 1;
	}
	else
	{
	pSuppInfo->generateMipmaps = 0;
	}

	// Check supercompression
	switch (pHeader->supercompressionScheme) {
	case KTX_SS_NONE:
	case KTX_SS_BASIS_LZ:
	case KTX_SS_ZSTD:
	case KTX_SS_ZLIB:
	break;
	default:
	// Unsupported supercompression
	return KTX_UNSUPPORTED_FEATURE;
	}

	// This test works for arrays too because height or depth will be 0.
	max_dim = MAX(MAX(pHeader->pixelWidth, pHeader->pixelHeight), pHeader->pixelDepth);
	if (max_dim < ((ktx_uint32_t)1 << (pHeader->levelCount - 1)))
	{
	// Can't have more mip levels than 1 + log2(max(width, height, depth))
	return KTX_FILE_DATA_ERROR;
	}

	return KTX_SUCCESS;

	}