Stowage/godot
2
0
Fork 0
mirror of https://github.com/godotengine/godot.git synced 2025-12-08 06:09:55 +00:00
Code Issues Projects Releases Packages Wiki Activity

basis_universal: Sync with latest Git to solve more warnings

Browse source
This commit is contained in:
Rémi Verschelde 2025-10-09 12:28:20 +02:00
parent 9a5d6d1049
commit 845f9f73cd
No known key found for this signature in database
GPG key ID: C3336907360768E1
23 changed files with 297 additions and 405 deletions
Download patch file Download diff file Expand all files Collapse all files

93
thirdparty/basis_universal/transcoder/basisu.h vendored
View file

@ -107,20 +107,7 @@ namespace basisu
debug_puts(res.c_str());
}
#ifndef __EMSCRIPTEN__
#if defined(__GNUC__) && !defined(__clang__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wclass-memaccess"
#endif
#endif
template <typename T> inline void clear_obj(T& obj) { memset(&obj, 0, sizeof(obj)); }
#ifndef __EMSCRIPTEN__
#if defined(__GNUC__) && !defined(__clang__)
#pragma GCC diagnostic pop
#endif
#endif
template <typename T> inline void clear_obj(T& obj) { memset((void *)&obj, 0, sizeof(obj)); }
constexpr double cPiD = 3.14159265358979323846264338327950288;
constexpr float REALLY_SMALL_FLOAT_VAL = .000000125f;
@ -348,6 +335,7 @@ namespace basisu
inline packed_uint& operator= (uint64_t v)
{
// TODO: Add assert on truncation?
for (uint32_t i = 0; i < NumBytes; i++)
m_bytes[i] = static_cast<uint8_t>(v >> (i * 8));
return *this;
@ -358,69 +346,10 @@ namespace basisu
memcpy(m_bytes, rhs.m_bytes, sizeof(m_bytes));
return *this;
}
#if 0
#ifdef __GNUC__
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Warray-bounds"
#endif
inline operator uint32_t() const
{
switch (NumBytes)
{
case 1:
{
return m_bytes[0];
}
case 2:
{
return (m_bytes[1] << 8U) | m_bytes[0];
}
case 3:
{
return (m_bytes[2] << 16U) | (m_bytes[1] << 8U) | m_bytes[0];
}
case 4:
{
return read_le_dword(m_bytes);
}
case 5:
{
uint32_t l = read_le_dword(m_bytes);
uint32_t h = m_bytes[4];
return static_cast<uint64_t>(l) | (static_cast<uint64_t>(h) << 32U);
}
case 6:
{
uint32_t l = read_le_dword(m_bytes);
uint32_t h = (m_bytes[5] << 8U) | m_bytes[4];
return static_cast<uint64_t>(l) | (static_cast<uint64_t>(h) << 32U);
}
case 7:
{
uint32_t l = read_le_dword(m_bytes);
uint32_t h = (m_bytes[6] << 16U) | (m_bytes[5] << 8U) | m_bytes[4];
return static_cast<uint64_t>(l) | (static_cast<uint64_t>(h) << 32U);
}
case 8:
{
uint32_t l = read_le_dword(m_bytes);
uint32_t h = read_le_dword(m_bytes + 4);
return static_cast<uint64_t>(l) | (static_cast<uint64_t>(h) << 32U);
}
default:
{
assert(0);
return 0;
}
}
}
#ifdef __GNUC__
#pragma GCC diagnostic pop
#endif
#else
inline operator uint32_t() const
inline uint64_t get_uint64() const
{
// Some compilers may warn about this code. It clearly cannot access beyond the end of the m_bytes struct here.
if constexpr (NumBytes == 1)
{
return m_bytes[0];
@ -467,8 +396,18 @@ namespace basisu
return 0;
}
}
#endif
inline uint32_t get_uint32() const
{
static_assert(NumBytes <= sizeof(uint32_t), "packed_uint too large to use get_uint32");
return static_cast<uint32_t>(get_uint64());
}
inline operator uint32_t() const
{
static_assert(NumBytes <= sizeof(uint32_t), "packed_uint too large to use operator uint32_t");
return static_cast<uint32_t>(get_uint64());
}
};
enum eZero { cZero };

1
thirdparty/basis_universal/transcoder/basisu_astc_helpers.h vendored
View file

@ -1,6 +1,5 @@
// basisu_astc_helpers.h
// Be sure to define ASTC_HELPERS_IMPLEMENTATION somewhere to get the implementation, otherwise you only get the header.
#pragma once
#ifndef BASISU_ASTC_HELPERS_HEADER
#define BASISU_ASTC_HELPERS_HEADER

50
thirdparty/basis_universal/transcoder/basisu_containers.h vendored
View file

@ -1503,22 +1503,10 @@ namespace basisu
if (BASISU_IS_BITWISE_COPYABLE(T))
{
#ifndef __EMSCRIPTEN__
#if defined(__GNUC__) && !defined(__clang__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wclass-memaccess"
#endif
#endif
if ((m_p) && (other.m_p))
{
memcpy(m_p, other.m_p, m_size * sizeof(T));
memcpy((void *)m_p, other.m_p, m_size * sizeof(T));
}
#ifndef __EMSCRIPTEN__
#if defined(__GNUC__) && !defined(__clang__)
#pragma GCC diagnostic pop
#endif
#endif
}
else
{
@ -1649,19 +1637,8 @@ namespace basisu
if (BASISU_IS_BITWISE_COPYABLE(T))
{
#ifndef __EMSCRIPTEN__
#if defined(__GNUC__) && !defined(__clang__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wclass-memaccess"
#endif
#endif
if ((m_p) && (other.m_p))
memcpy(m_p, other.m_p, other.m_size * sizeof(T));
#ifndef __EMSCRIPTEN__
#if defined(__GNUC__) && !defined(__clang__)
#pragma GCC diagnostic pop
#endif
#endif
memcpy((void *)m_p, other.m_p, other.m_size * sizeof(T));
}
else
{
@ -2233,21 +2210,7 @@ namespace basisu
}
// Copy "down" the objects to preserve, filling in the empty slots.
#ifndef __EMSCRIPTEN__
#if defined(__GNUC__) && !defined(__clang__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wclass-memaccess"
#endif
#endif
memmove(pDst, pSrc, num_to_move * sizeof(T));
#ifndef __EMSCRIPTEN__
#if defined(__GNUC__) && !defined(__clang__)
#pragma GCC diagnostic pop
#endif
#endif
memmove((void *)pDst, pSrc, num_to_move * sizeof(T));
}
else
{
@ -2492,18 +2455,13 @@ namespace basisu
{
if ((sizeof(T) == 1) && (scalar_type<T>::cFlag))
{
#ifndef __EMSCRIPTEN__
#if defined(__GNUC__) && !defined(__clang__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wclass-memaccess"
#endif
#pragma GCC diagnostic ignored "-Wclass-memaccess"
#endif
memset(m_p, *reinterpret_cast<const uint8_t*>(&o), m_size);
#ifndef __EMSCRIPTEN__
#if defined(__GNUC__) && !defined(__clang__)
#pragma GCC diagnostic pop
#endif
#endif
}
else

73
thirdparty/basis_universal/transcoder/basisu_transcoder.cpp vendored
View file

@ -16,11 +16,11 @@
#include "basisu_transcoder.h"
#include "basisu_containers_impl.h"
#include "basisu_astc_hdr_core.h"
#define BASISU_ASTC_HELPERS_IMPLEMENTATION
#include "basisu_astc_helpers.h"
#include "basisu_astc_hdr_core.h"
#include <limits.h>
#if defined(_MSC_VER)
@ -4622,6 +4622,7 @@ namespace basist
const int CHROMA_THRESH = 10;
uint32_t total_filtered_blocks = 0;
BASISU_NOTE_UNUSED(total_filtered_blocks);
for (int by = 0; by < (int)num_blocks_y; by++)
{
@ -9446,7 +9447,7 @@ namespace basist
void* pOutput_blocks, uint32_t output_blocks_buf_size_in_blocks_or_pixels,
const uint8_t* pCompressed_data, uint32_t compressed_data_length,
uint32_t num_blocks_x, uint32_t num_blocks_y, uint32_t orig_width, uint32_t orig_height, uint32_t level_index,
uint32_t rgb_offset, uint32_t rgb_length, uint32_t alpha_offset, uint32_t alpha_length,
uint64_t rgb_offset, uint32_t rgb_length, uint64_t alpha_offset, uint32_t alpha_length,
uint32_t decode_flags,
bool basis_file_has_alpha_slices,
bool is_video,
@ -10311,7 +10312,7 @@ namespace basist
void* pOutput_blocks, uint32_t output_blocks_buf_size_in_blocks_or_pixels,
const uint8_t* pCompressed_data, uint32_t compressed_data_length,
uint32_t num_blocks_x, uint32_t num_blocks_y, uint32_t orig_width, uint32_t orig_height, uint32_t level_index,
uint32_t slice_offset, uint32_t slice_length,
uint64_t slice_offset, uint32_t slice_length,
uint32_t decode_flags,
bool has_alpha,
bool is_video,
@ -10802,7 +10803,7 @@ namespace basist
void* pOutput_blocks, uint32_t output_blocks_buf_size_in_blocks_or_pixels,
const uint8_t* pCompressed_data, uint32_t compressed_data_length,
uint32_t num_blocks_x, uint32_t num_blocks_y, uint32_t orig_width, uint32_t orig_height, uint32_t level_index,
uint32_t slice_offset, uint32_t slice_length,
uint64_t slice_offset, uint32_t slice_length,
uint32_t decode_flags,
bool has_alpha,
bool is_video,
@ -11238,7 +11239,7 @@ namespace basist
void* pOutput_blocks, uint32_t output_blocks_buf_size_in_blocks_or_pixels,
const uint8_t* pCompressed_data, uint32_t compressed_data_length,
uint32_t num_blocks_x, uint32_t num_blocks_y, uint32_t orig_width, uint32_t orig_height, uint32_t level_index,
uint32_t slice_offset, uint32_t slice_length,
uint64_t slice_offset, uint32_t slice_length,
uint32_t decode_flags,
bool has_alpha,
bool is_video,
@ -11685,7 +11686,7 @@ namespace basist
void* pOutput_blocks, uint32_t output_blocks_buf_size_in_blocks_or_pixels,
const uint8_t* pCompressed_data, uint32_t compressed_data_length,
uint32_t num_blocks_x, uint32_t num_blocks_y, uint32_t orig_width, uint32_t orig_height, uint32_t level_index,
uint32_t slice_offset, uint32_t slice_length,
uint64_t slice_offset, uint32_t slice_length,
uint32_t decode_flags,
bool has_alpha,
bool is_video,
@ -18847,11 +18848,11 @@ namespace basist
m_pData = nullptr;
m_data_size = 0;
memset(&m_header, 0, sizeof(m_header));
memset((void *)&m_header, 0, sizeof(m_header));
m_levels.clear();
m_dfd.clear();
m_key_values.clear();
memset(&m_etc1s_header, 0, sizeof(m_etc1s_header));
memset((void *)&m_etc1s_header, 0, sizeof(m_etc1s_header));
m_etc1s_image_descs.clear();
m_astc_6x6_intermediate_image_descs.clear();
@ -18900,7 +18901,7 @@ namespace basist
m_pData = static_cast<const uint8_t *>(pData);
m_data_size = data_size;
memcpy(&m_header, pData, sizeof(m_header));
memcpy((void *)&m_header, pData, sizeof(m_header));
// Check for supported VK formats. We may also need to parse the DFD.
if ((m_header.m_vk_format != KTX2_VK_FORMAT_UNDEFINED) &&
@ -18973,13 +18974,13 @@ namespace basist
}
#endif
if (m_header.m_sgd_byte_offset < sizeof(ktx2_header))
if (m_header.m_sgd_byte_offset.get_uint64() < sizeof(ktx2_header))
{
BASISU_DEVEL_ERROR("ktx2_transcoder::init: Supercompression global data offset is too low\n");
return false;
}
if (m_header.m_sgd_byte_offset + m_header.m_sgd_byte_length > m_data_size)
if (m_header.m_sgd_byte_offset.get_uint64() + m_header.m_sgd_byte_length.get_uint64() > m_data_size)
{
BASISU_DEVEL_ERROR("ktx2_transcoder::init: Supercompression global data offset and/or length is too high\n");
return false;
@ -19000,23 +19001,23 @@ namespace basist
return false;
}
memcpy(&m_levels[0], m_pData + sizeof(ktx2_header), level_index_size_in_bytes);
memcpy((void *)&m_levels[0], m_pData + sizeof(ktx2_header), level_index_size_in_bytes);
// Sanity check the level offsets and byte sizes
for (uint32_t i = 0; i < m_levels.size(); i++)
{
if (m_levels[i].m_byte_offset < sizeof(ktx2_header))
if (m_levels[i].m_byte_offset.get_uint64() < sizeof(ktx2_header))
{
BASISU_DEVEL_ERROR("ktx2_transcoder::init: Invalid level offset (too low)\n");
return false;
}
if (!m_levels[i].m_byte_length)
if (!m_levels[i].m_byte_length.get_uint64())
{
BASISU_DEVEL_ERROR("ktx2_transcoder::init: Invalid level byte length\n");
}
if ((m_levels[i].m_byte_offset + m_levels[i].m_byte_length) > m_data_size)
if ((m_levels[i].m_byte_offset.get_uint64() + m_levels[i].m_byte_length.get_uint64()) > m_data_size)
{
BASISU_DEVEL_ERROR("ktx2_transcoder::init: Invalid level offset and/or length\n");
return false;
@ -19024,7 +19025,7 @@ namespace basist
const uint64_t MAX_SANE_LEVEL_UNCOMP_SIZE = 2048ULL * 1024ULL * 1024ULL;
if (m_levels[i].m_uncompressed_byte_length >= MAX_SANE_LEVEL_UNCOMP_SIZE)
if (m_levels[i].m_uncompressed_byte_length.get_uint64() >= MAX_SANE_LEVEL_UNCOMP_SIZE)
{
BASISU_DEVEL_ERROR("ktx2_transcoder::init: Invalid level offset (too large)\n");
return false;
@ -19032,7 +19033,7 @@ namespace basist
if (m_header.m_supercompression_scheme == KTX2_SS_BASISLZ)
{
if (m_levels[i].m_uncompressed_byte_length)
if (m_levels[i].m_uncompressed_byte_length.get_uint64())
{
BASISU_DEVEL_ERROR("ktx2_transcoder::init: Invalid uncompressed length (0)\n");
return false;
@ -19040,7 +19041,7 @@ namespace basist
}
else if (m_header.m_supercompression_scheme >= KTX2_SS_ZSTANDARD)
{
if (!m_levels[i].m_uncompressed_byte_length)
if (!m_levels[i].m_uncompressed_byte_length.get_uint64())
{
BASISU_DEVEL_ERROR("ktx2_transcoder::init: Invalid uncompressed length (1)\n");
return false;
@ -19435,8 +19436,8 @@ namespace basist
return false;
}
const uint8_t* pComp_level_data = m_pData + m_levels[level_index].m_byte_offset;
uint64_t comp_level_data_size = m_levels[level_index].m_byte_length;
const uint8_t* pComp_level_data = m_pData + m_levels[level_index].m_byte_offset.get_uint64();
uint64_t comp_level_data_size = m_levels[level_index].m_byte_length.get_uint64();
const uint8_t* pUncomp_level_data = pComp_level_data;
uint64_t uncomp_level_data_size = comp_level_data_size;
@ -19498,8 +19499,8 @@ namespace basist
pOutput_blocks, output_blocks_buf_size_in_blocks_or_pixels, m_pData, m_data_size,
num_blocks4_x, num_blocks4_y, level_width, level_height,
level_index,
m_levels[level_index].m_byte_offset + image_desc.m_rgb_slice_byte_offset, image_desc.m_rgb_slice_byte_length,
image_desc.m_alpha_slice_byte_length ? (m_levels[level_index].m_byte_offset + image_desc.m_alpha_slice_byte_offset) : 0, image_desc.m_alpha_slice_byte_length,
m_levels[level_index].m_byte_offset.get_uint64() + image_desc.m_rgb_slice_byte_offset, image_desc.m_rgb_slice_byte_length,
image_desc.m_alpha_slice_byte_length ? (m_levels[level_index].m_byte_offset.get_uint64() + image_desc.m_alpha_slice_byte_offset) : 0, image_desc.m_alpha_slice_byte_length,
decode_flags, m_has_alpha,
m_is_video, output_row_pitch_in_blocks_or_pixels, &pState->m_transcoder_state, output_rows_in_pixels))
{
@ -19536,7 +19537,7 @@ namespace basist
if (!m_astc_hdr_6x6_intermediate_transcoder.transcode_image(fmt,
pOutput_blocks, output_blocks_buf_size_in_blocks_or_pixels,
m_pData, m_data_size, num_blocks6_x, num_blocks6_y, level_width, level_height, level_index,
m_levels[level_index].m_byte_offset + image_desc.m_rgb_slice_byte_offset, image_desc.m_rgb_slice_byte_length,
m_levels[level_index].m_byte_offset.get_uint64() + image_desc.m_rgb_slice_byte_offset, image_desc.m_rgb_slice_byte_length,
decode_flags, m_has_alpha, m_is_video, output_row_pitch_in_blocks_or_pixels, nullptr, output_rows_in_pixels, channel0, channel1))
{
BASISU_DEVEL_ERROR("ktx2_transcoder::transcode_image_2D: ASTC 6x6 HDR transcode_image() failed, this is either a bug or the file is corrupted/invalid\n");
@ -19549,7 +19550,7 @@ namespace basist
const uint32_t num_blocks6_y = (level_height + 5) / 6;
// Compute length and offset to uncompressed 2D UASTC texture data, given the face/layer indices.
assert(uncomp_level_data_size == m_levels[level_index].m_uncompressed_byte_length);
assert(uncomp_level_data_size == m_levels[level_index].m_uncompressed_byte_length.get_uint64());
const uint32_t total_2D_image_size = num_blocks6_x * num_blocks6_y * sizeof(astc_helpers::astc_block);
const uint32_t uncomp_ofs = (layer_index * m_header.m_face_count + face_index) * total_2D_image_size;
@ -19581,7 +19582,7 @@ namespace basist
(m_format == basist::basis_tex_format::cUASTC_HDR_4x4))
{
// Compute length and offset to uncompressed 2D UASTC texture data, given the face/layer indices.
assert(uncomp_level_data_size == m_levels[level_index].m_uncompressed_byte_length);
assert(uncomp_level_data_size == m_levels[level_index].m_uncompressed_byte_length.get_uint64());
const uint32_t total_2D_image_size = num_blocks4_x * num_blocks4_y * KTX2_UASTC_BLOCK_SIZE;
const uint32_t uncomp_ofs = (layer_index * m_header.m_face_count + face_index) * total_2D_image_size;
@ -19637,10 +19638,10 @@ namespace basist
bool ktx2_transcoder::decompress_level_data(uint32_t level_index, basisu::uint8_vec& uncomp_data)
{
const uint8_t* pComp_data = m_levels[level_index].m_byte_offset + m_pData;
const uint64_t comp_size = m_levels[level_index].m_byte_length;
const uint8_t* pComp_data = m_levels[level_index].m_byte_offset.get_uint64() + m_pData;
const uint64_t comp_size = m_levels[level_index].m_byte_length.get_uint64();
const uint64_t uncomp_size = m_levels[level_index].m_uncompressed_byte_length;
const uint64_t uncomp_size = m_levels[level_index].m_uncompressed_byte_length.get_uint64();
if (((size_t)comp_size) != comp_size)
{
@ -19687,9 +19688,9 @@ namespace basist
const uint32_t image_count = basisu::maximum<uint32_t>(m_header.m_layer_count, 1) * m_header.m_face_count * m_header.m_level_count;
assert(image_count);
const uint8_t* pSrc = m_pData + m_header.m_sgd_byte_offset;
const uint8_t* pSrc = m_pData + m_header.m_sgd_byte_offset.get_uint64();
if (m_header.m_sgd_byte_length != image_count * sizeof(ktx2_astc_hdr_6x6_intermediate_image_desc))
if (m_header.m_sgd_byte_length.get_uint64() != image_count * sizeof(ktx2_astc_hdr_6x6_intermediate_image_desc))
{
BASISU_DEVEL_ERROR("ktx2_transcoder::decompress_astc_6x6_hdr_intermediate_global_data: Invalid global data length\n");
return false;
@ -19697,7 +19698,7 @@ namespace basist
m_astc_6x6_intermediate_image_descs.resize(image_count);
memcpy(m_astc_6x6_intermediate_image_descs.data(), pSrc, sizeof(ktx2_astc_hdr_6x6_intermediate_image_desc) * image_count);
memcpy((void *)m_astc_6x6_intermediate_image_descs.data(), pSrc, sizeof(ktx2_astc_hdr_6x6_intermediate_image_desc) * image_count);
// Sanity check the image descs
for (uint32_t i = 0; i < image_count; i++)
@ -19724,9 +19725,9 @@ namespace basist
const uint32_t image_count = basisu::maximum<uint32_t>(m_header.m_layer_count, 1) * m_header.m_face_count * m_header.m_level_count;
assert(image_count);
const uint8_t* pSrc = m_pData + m_header.m_sgd_byte_offset;
const uint8_t* pSrc = m_pData + m_header.m_sgd_byte_offset.get_uint64();
memcpy(&m_etc1s_header, pSrc, sizeof(ktx2_etc1s_global_data_header));
memcpy((void *)&m_etc1s_header, pSrc, sizeof(ktx2_etc1s_global_data_header));
pSrc += sizeof(ktx2_etc1s_global_data_header);
if ((!m_etc1s_header.m_endpoints_byte_length) || (!m_etc1s_header.m_selectors_byte_length) || (!m_etc1s_header.m_tables_byte_length))
@ -19747,7 +19748,7 @@ namespace basist
m_etc1s_header.m_endpoints_byte_length +
m_etc1s_header.m_selectors_byte_length +
m_etc1s_header.m_tables_byte_length +
m_etc1s_header.m_extended_byte_length) > m_header.m_sgd_byte_length)
m_etc1s_header.m_extended_byte_length) > m_header.m_sgd_byte_length.get_uint64())
{
BASISU_DEVEL_ERROR("ktx2_transcoder::decompress_etc1s_global_data: SGD byte length is too small, file is invalid or corrupted\n");
return false;
@ -19759,7 +19760,7 @@ namespace basist
return false;
}
memcpy(m_etc1s_image_descs.data(), pSrc, sizeof(ktx2_etc1s_image_desc) * image_count);
memcpy((void *)m_etc1s_image_descs.data(), pSrc, sizeof(ktx2_etc1s_image_desc) * image_count);
pSrc += sizeof(ktx2_etc1s_image_desc) * image_count;
// Sanity check the ETC1S image descs

10
thirdparty/basis_universal/transcoder/basisu_transcoder.h vendored
View file

@ -254,7 +254,7 @@ namespace basist
void* pOutput_blocks, uint32_t output_blocks_buf_size_in_blocks_or_pixels,
const uint8_t* pCompressed_data, uint32_t compressed_data_length,
uint32_t num_blocks_x, uint32_t num_blocks_y, uint32_t orig_width, uint32_t orig_height, uint32_t level_index,
uint32_t rgb_offset, uint32_t rgb_length, uint32_t alpha_offset, uint32_t alpha_length,
uint64_t rgb_offset, uint32_t rgb_length, uint64_t alpha_offset, uint32_t alpha_length,
uint32_t decode_flags = 0,
bool basis_file_has_alpha_slices = false,
bool is_video = false,
@ -342,7 +342,7 @@ namespace basist
void* pOutput_blocks, uint32_t output_blocks_buf_size_in_blocks_or_pixels,
const uint8_t* pCompressed_data, uint32_t compressed_data_length,
uint32_t num_blocks_x, uint32_t num_blocks_y, uint32_t orig_width, uint32_t orig_height, uint32_t level_index,
uint32_t slice_offset, uint32_t slice_length,
uint64_t slice_offset, uint32_t slice_length,
uint32_t decode_flags = 0,
bool has_alpha = false,
bool is_video = false,
@ -379,7 +379,7 @@ namespace basist
void* pOutput_blocks, uint32_t output_blocks_buf_size_in_blocks_or_pixels,
const uint8_t* pCompressed_data, uint32_t compressed_data_length,
uint32_t num_blocks_x, uint32_t num_blocks_y, uint32_t orig_width, uint32_t orig_height, uint32_t level_index,
uint32_t slice_offset, uint32_t slice_length,
uint64_t slice_offset, uint32_t slice_length,
uint32_t decode_flags = 0,
bool has_alpha = false,
bool is_video = false,
@ -416,7 +416,7 @@ namespace basist
void* pOutput_blocks, uint32_t output_blocks_buf_size_in_blocks_or_pixels,
const uint8_t* pCompressed_data, uint32_t compressed_data_length,
uint32_t num_blocks_x, uint32_t num_blocks_y, uint32_t orig_width, uint32_t orig_height, uint32_t level_index,
uint32_t slice_offset, uint32_t slice_length,
uint64_t slice_offset, uint32_t slice_length,
uint32_t decode_flags = 0,
bool has_alpha = false,
bool is_video = false,
@ -453,7 +453,7 @@ namespace basist
void* pOutput_blocks, uint32_t output_blocks_buf_size_in_blocks_or_pixels,
const uint8_t* pCompressed_data, uint32_t compressed_data_length,
uint32_t num_blocks_x, uint32_t num_blocks_y, uint32_t orig_width, uint32_t orig_height, uint32_t level_index,
uint32_t slice_offset, uint32_t slice_length,
uint64_t slice_offset, uint32_t slice_length,
uint32_t decode_flags = 0,
bool has_alpha = false,
bool is_video = false,