// basis_wrappers.cpp - Wrappers to the C++ compressor and transcoder for WebAssembly/WebGL use.

// This file exposes wrappers for transcoding and encoding .basis and .KTX2 files.

//

// **Important**:

// Compile with -fno-strict-aliasing (same as the Linux kernel).

// This code HAS NOT been tested with strict aliasing enabled.

// The "initializeBasis()" function MUST be called at least once before using either the compressor or transcoder.

//

// There are four main categories of wrappers in this module:

// 1. Transcoding, low-level .basis file information: See class basis_file. Only depends on transcoder/basisu_transcoder.cpp.

// getFileDesc(), getImageDesc(), getImageLevelDesc(): These functions return low-level information about where compressed data is located for each image in a .basis file.

// This is useful for when you want to extract the compressed data and embed it into your own file formats, for container independent transcoding.

//

// 2. Encoding (optional): See class basis_encoder. Encodes LDR .PNG or 32bpp images, or HDR half-float/float or .EXR/.HDR images to .basis/.ktx2 files in memory.

// Must compile with BASISU_SUPPORT_ENCODING=1.

// Requires basisu_transcoder.cpp as well as all the .cpp files in the "encoder" directory. Results in a larger WebAssembly executable.

//

// 3. Low level transcoding/container independent transcoding: See class lowlevel_etc1s_image_transcoder or function transcodeUASTCImage().

// For transcoding raw compressed ETC1S/UASTC LDR/UASTC HDR texture data from non-.basis files (say from KTX2) to GPU texture data.

//

// 4. Helpers, transcoder texture format information: See functions getBytesPerBlockOrPixel(), formatHasAlpha(), etc.

//

// Note: The thread pool size is setup in the CMakeLists.txt file:

// set(LINK_THREADS "-s USE_PTHREADS=1 -s PTHREAD_POOL_SIZE=32 -s ENVIRONMENT=web,worker")

// If BASISU_SUPPORT_ENCODING is 1, wrappers for the compressor will be included. Otherwise, only the wrappers for the transcoder will be compiled in.

#ifndef BASISU_SUPPORT_ENCODING

#define BASISU_SUPPORT_ENCODING 0

#endif

// Enable debug printf()'s in this module.

#ifndef BASISU_DEBUG_PRINTF

// DO NOT CHECK IN

#define BASISU_DEBUG_PRINTF 0

#endif

// This check can be removed, but you risk crashing on larger images in 32-bit WASM. Also, ETC1S/UASTC LDR 4x4 encoding uses way less memory than UASTC HDR 6x6 encoding, so you could boost this in those cases.

// 32-bit WASM limitation (TODO: remove for 64-bit), to prevent OOM crashes during HDR encoding in particular.

// TODO: Even WASM64 in Chrome has limits which seem too low for us. For now, just impose this limit.

#ifdef __wasm64__

#define BASISU_ENCODER_MAX_SOURCE_IMAGE_PIXELS (1024*1024*16)

#define BASISU_ENCODER_MAX_SOURCE_IMAGE_PIXELS_HIGHER_LIMIT (1024*1024*16)

#else

#define BASISU_ENCODER_MAX_SOURCE_IMAGE_PIXELS (1024*1024*4)

#define BASISU_ENCODER_MAX_SOURCE_IMAGE_PIXELS_HIGHER_LIMIT (1024*1024*12)

#endif

#include "basisu_transcoder.h"

#include <algorithm>

#if BASISU_SUPPORT_ENCODING

#include "../../encoder/basisu_comp.h"

#include "../../encoder/basisu_astc_hdr_6x6_enc.h"

#include "../../encoder/basisu_resampler_filters.h"

#include "../../encoder/basisu_gpu_texture.h" // for basisu::transcode_ktx2_to_dds()

#include "../../encoder/basisu_dds_export.h" // direct source->DDS export (build_dds), distinct from the lossy KTX2->DDS path above

#endif

#include <emscripten/bind.h>

#if BASISU_SUPPORT_ENCODING

#include <emscripten/threading.h>

#endif

#include <emscripten.h>

using namespace emscripten;

using namespace basist;

using namespace basisu;

static bool g_basis_initialized_flag;

// Global one-time initialization. MUST be called before using any other functionality.

void basis_init()

{

static std::mutex s_init_mutex;

std::lock_guard<std::mutex> lock(s_init_mutex);

#if BASISU_DEBUG_PRINTF

printf("basis_init() " BASISD_VERSION_STRING " ");

#ifdef __wasm64__

printf("WASM64 ");

#endif

#ifdef WASM_THREADS_ENABLED

printf("PTHREADS");

#endif

printf("\n");

#endif

if (g_basis_initialized_flag)

return;

#if BASISU_SUPPORT_ENCODING

basisu_encoder_init();

#endif

basisu_transcoder_init();

g_basis_initialized_flag = true;

}

#if 0

// Old copy methods, used in previous builds for plain WASM (not WASM64).

// false if resize() fails

static bool copy_from_jsbuffer(const emscripten::val& srcBuffer, basisu::vector<uint8_t>& dstVec)

{

unsigned int length = srcBuffer["length"].as<unsigned int>();

if (!dstVec.try_resize(length))

return false;

emscripten::val memory = emscripten::val::module_property("HEAP8")["buffer"];

emscripten::val memoryView = srcBuffer["constructor"].new_(memory, reinterpret_cast<uintptr_t>(dstVec.data()), length);

// Copy the bytes from the Javascript buffer.

memoryView.call<void>("set", srcBuffer);

return true;

}

static bool copy_to_jsbuffer(const emscripten::val& dstBuffer, const basisu::vector<uint8_t>& srcVec)

{

if (srcVec.empty())

{

#if BASISU_DEBUG_PRINTF

printf("copy_to_jsbuffer: Provided source buffer is empty\n");

#endif

return false;

}

// Make sure the provided buffer from Javascript is big enough. If not, bail.

int dstBufferLen = dstBuffer["byteLength"].as<int>();

if (srcVec.size() > dstBufferLen)

{

#if BASISU_DEBUG_PRINTF

printf("copy_to_jsbuffer: Provided destination buffer is too small (wanted %u bytes, got %u bytes)!\n", (uint32_t)srcVec.size(), dstBufferLen);

#endif

assert(0);

return false;

}

emscripten::val memory = emscripten::val::module_property("HEAP8")["buffer"];

emscripten::val memoryView = emscripten::val::global("Uint8Array").new_(memory, reinterpret_cast<uintptr_t>(srcVec.data()), srcVec.size());

// Copy the bytes into the Javascript buffer.

dstBuffer.call<void>("set", memoryView);

return true;

}

#else

// New methods, compatible with WASM64.

static bool copy_from_jsbuffer(const emscripten::val& srcBuffer, basisu::vector<uint8_t>& dstVec)

{

const size_t length = srcBuffer["length"].as<size_t>();

if (!dstVec.try_resize(length))

return false;

// View over dstVec in WASM memory; copy from JS buffer into it.

emscripten::val dstView = emscripten::val(emscripten::typed_memory_view(length, dstVec.data()));

dstView.call<void>("set", srcBuffer);

return true;

}

// WASM -> JS

static bool copy_to_jsbuffer(const emscripten::val& dstBuffer, const basisu::vector<uint8_t>& srcVec)

{

if (srcVec.empty())

return false;

const size_t dstLen = dstBuffer["byteLength"].as<size_t>();

if (srcVec.size() > dstLen)

return false;

// View over srcVec; copy into provided JS TypedArray.

emscripten::val srcView = emscripten::val(emscripten::typed_memory_view(srcVec.size(), const_cast<uint8_t*>(srcVec.data())));

dstBuffer.call<void>("set", srcView);

return true;

}

#endif

const uint32_t BASIS_MAGIC = 0xD4ADBEA1;

const uint32_t KTX2_MAGIC = 0xD4ADBEF2;

const uint32_t DDS_MAGIC = 0xD4ADBEF3;

struct basis_file_desc

{

uint32_t m_version;

uint32_t m_us_per_frame;

uint32_t m_total_images;

uint32_t m_userdata0;

uint32_t m_userdata1;

// Type of texture (cETC1S, cUASTC_LDR_4x4, cUASTC_HDR_4x4, etc.)

uint32_t m_tex_format; // basis_tex_format

bool m_y_flipped;

bool m_has_alpha_slices;

// ETC1S endpoint codebook

uint32_t m_num_endpoints;

uint32_t m_endpoint_palette_ofs;

uint32_t m_endpoint_palette_len;

// ETC1S selector codebook

uint32_t m_num_selectors;

uint32_t m_selector_palette_ofs;

uint32_t m_selector_palette_len;

// Huffman codelength tables

uint32_t m_tables_ofs;

uint32_t m_tables_len;

uint32_t m_block_width;

uint32_t m_block_height;

};

struct basis_image_desc

{

uint32_t m_orig_width;

uint32_t m_orig_height;

uint32_t m_num_blocks_x;

uint32_t m_num_blocks_y;

uint32_t m_num_levels;

uint32_t m_block_width;

uint32_t m_block_height;

// Will be true if the image has alpha (for UASTC this may vary per-image)

bool m_alpha_flag;

bool m_iframe_flag;

};

struct basis_image_level_desc

{

// File offset/length of the compressed ETC1S or UASTC LDR/HDR texture data.

uint32_t m_rgb_file_ofs;

uint32_t m_rgb_file_len;

// Optional alpha data file offset/length - will be 0's for UASTC LDR/HDR or opaque ETC1S files.

uint32_t m_alpha_file_ofs;

uint32_t m_alpha_file_len;

};

struct basis_file

{

int m_magic = 0;

basisu_transcoder m_transcoder;

basisu::vector<uint8_t> m_file;

basis_file(const emscripten::val& jsBuffer)

: m_file(jsBuffer["byteLength"].as<size_t>())

{

if (!g_basis_initialized_flag)

{

#if BASISU_DEBUG_PRINTF

printf("basis_file::basis_file: Must call basis_init() first!\n");

#endif

assert(0);

return;

}

#if 0

unsigned int length = jsBuffer["length"].as<unsigned int>();

emscripten::val memory = emscripten::val::module_property("HEAP8")["buffer"];

emscripten::val memoryView = jsBuffer["constructor"].new_(memory, reinterpret_cast<uintptr_t>(m_file.data()), length);

memoryView.call<void>("set", jsBuffer);

#else

const size_t n = jsBuffer["byteLength"].as<size_t>();

if (!n)

{

#if BASISU_DEBUG_PRINTF

printf("basis_file::basis_file: zero size file\n");

#endif

m_file.clear();

return;

}

emscripten::val dstView = emscripten::val(emscripten::typed_memory_view(n, m_file.data()));

dstView.call<void>("set", jsBuffer);

#endif

if (!m_transcoder.validate_header(m_file.data(), m_file.size()))

{

#if BASISU_DEBUG_PRINTF

printf("basis_file::basis_file: m_transcoder.validate_header() failed!\n");

#endif

m_file.clear();

}

// Initialized after validation

m_magic = BASIS_MAGIC;

}

void close()

{

assert(m_magic == BASIS_MAGIC);

if (m_magic != BASIS_MAGIC)

return;

m_file.clear();

}

uint32_t getHasAlpha()

{

assert(m_magic == BASIS_MAGIC);

if (m_magic != BASIS_MAGIC)

return 0;

basisu_image_level_info li;

if (!m_transcoder.get_image_level_info(m_file.data(), m_file.size(), li, 0, 0))

return 0;

return li.m_alpha_flag;

}

uint32_t getNumImages()

{

assert(m_magic == BASIS_MAGIC);

if (m_magic != BASIS_MAGIC)

return 0;

return m_transcoder.get_total_images(m_file.data(), m_file.size());

}

uint32_t getNumLevels(uint32_t image_index)

{

assert(m_magic == BASIS_MAGIC);

if (m_magic != BASIS_MAGIC)

return 0;

basisu_image_info ii;

if (!m_transcoder.get_image_info(m_file.data(), m_file.size(), ii, image_index))

return 0;

return ii.m_total_levels;

}

uint32_t getImageWidth(uint32_t image_index, uint32_t level_index)

{

assert(m_magic == BASIS_MAGIC);

if (m_magic != BASIS_MAGIC)

return 0;

uint32_t orig_width, orig_height, total_blocks;

if (!m_transcoder.get_image_level_desc(m_file.data(), m_file.size(), image_index, level_index, orig_width, orig_height, total_blocks))

return 0;

return orig_width;

}

uint32_t getImageHeight(uint32_t image_index, uint32_t level_index)

{

assert(m_magic == BASIS_MAGIC);

if (m_magic != BASIS_MAGIC)

return 0;

uint32_t orig_width, orig_height, total_blocks;

if (!m_transcoder.get_image_level_desc(m_file.data(), m_file.size(), image_index, level_index, orig_width, orig_height, total_blocks))

return 0;

return orig_height;

}

// Returns a basis_tex_format (cETC1S, cUASTC_LDR_4x4, cUASTC_HDR_4x4, etc. - see basiu_file_headers.h)

uint32_t getBasisTexFormat()

{

assert(m_magic == BASIS_MAGIC);

if (m_magic != BASIS_MAGIC)

return false;

basis_tex_format fmt = m_transcoder.get_basis_tex_format(m_file.data(), m_file.size());

return (uint32_t)fmt;

}

// Returns 4-12

uint32_t getBlockWidth() const

{

assert(m_magic == BASIS_MAGIC);

if (m_magic != BASIS_MAGIC)

return false;

basis_tex_format fmt = m_transcoder.get_basis_tex_format(m_file.data(), m_file.size());

return basis_tex_format_get_block_width(fmt);

}

// Returns 4-12

uint32_t getBlockHeight()

{

assert(m_magic == BASIS_MAGIC);

if (m_magic != BASIS_MAGIC)

return false;

basis_tex_format fmt = m_transcoder.get_basis_tex_format(m_file.data(), m_file.size());

return basis_tex_format_get_block_height(fmt);

}

basis_file_desc getFileDesc()

{

basis_file_desc result;

memset(&result, 0, sizeof(result));

assert(m_magic == BASIS_MAGIC);

if (m_magic != BASIS_MAGIC)

return result;

basisu_file_info file_info;

if (!m_transcoder.get_file_info(m_file.data(), m_file.size(), file_info))

{

assert(0);

return result;

}

result.m_version = file_info.m_version;

result.m_us_per_frame = file_info.m_us_per_frame;

result.m_total_images = file_info.m_total_images;

result.m_userdata0 = file_info.m_userdata0;

result.m_userdata1 = file_info.m_userdata1;

result.m_tex_format = static_cast<uint32_t>(file_info.m_tex_format);

result.m_y_flipped = file_info.m_y_flipped;

result.m_has_alpha_slices = file_info.m_has_alpha_slices;

result.m_num_endpoints = file_info.m_total_endpoints;

result.m_endpoint_palette_ofs = file_info.m_endpoint_codebook_ofs;

result.m_endpoint_palette_len = file_info.m_endpoint_codebook_size;

result.m_num_selectors = file_info.m_total_selectors;

result.m_selector_palette_ofs = file_info.m_selector_codebook_ofs;

result.m_selector_palette_len = file_info.m_selector_codebook_size;

result.m_tables_ofs = file_info.m_tables_ofs;

result.m_tables_len = file_info.m_tables_size;

result.m_block_width = file_info.m_block_width;

result.m_block_height = file_info.m_block_height;

return result;

}

basis_image_desc getImageDesc(uint32_t image_index)

{

basis_image_desc result;

memset(&result, 0, sizeof(result));

assert(m_magic == BASIS_MAGIC);

if (m_magic != BASIS_MAGIC)

return result;

basisu_image_info image_info;

// bool get_image_info(const void *pData, uint32_t data_size, basisu_image_info &image_info, uint32_t image_index) const;

if (!m_transcoder.get_image_info(m_file.data(), m_file.size(), image_info, image_index))

{

assert(0);

return result;

}

result.m_orig_width = image_info.m_orig_width;

result.m_orig_height = image_info.m_orig_height;

result.m_num_blocks_x = image_info.m_num_blocks_x;

result.m_num_blocks_y = image_info.m_num_blocks_y;

result.m_num_levels = image_info.m_total_levels;

result.m_alpha_flag = image_info.m_alpha_flag;

result.m_iframe_flag = image_info.m_iframe_flag;

result.m_block_width = image_info.m_block_width;

result.m_block_height = image_info.m_block_height;

return result;

}

basis_image_level_desc getImageLevelDesc(uint32_t image_index, uint32_t level_index)

{

basis_image_level_desc result;

memset(&result, 0, sizeof(result));

assert(m_magic == BASIS_MAGIC);

if (m_magic != BASIS_MAGIC)

return result;

basisu_image_level_info image_info;

if (!m_transcoder.get_image_level_info(m_file.data(), m_file.size(), image_info, image_index, level_index))

{

assert(0);

return result;

}

result.m_rgb_file_ofs = image_info.m_rgb_file_ofs;

result.m_rgb_file_len = image_info.m_rgb_file_len;

result.m_alpha_file_ofs = image_info.m_alpha_file_ofs;

result.m_alpha_file_len = image_info.m_alpha_file_len;

return result;

}

// format is transcoder_texture_format

uint32_t getImageTranscodedSizeInBytes(uint32_t image_index, uint32_t level_index, uint32_t format)

{

assert(m_magic == BASIS_MAGIC);

if (m_magic != BASIS_MAGIC)

return 0;

if (format >= (int)transcoder_texture_format::cTFTotalTextureFormats)

{

assert(0);

return 0;

}

const transcoder_texture_format tex_format = static_cast<transcoder_texture_format>(format);

uint32_t orig_width, orig_height, total_src_blocks;

if (!m_transcoder.get_image_level_desc(m_file.data(), m_file.size(), image_index, level_index, orig_width, orig_height, total_src_blocks))

{

assert(0);

return 0;

}

return basis_compute_transcoded_image_size_in_bytes(tex_format, orig_width, orig_height);

}

// Only true for UASTC LDR 4x4.

bool isUASTC_LDR_4x4()

{

assert(m_magic == BASIS_MAGIC);

if (m_magic != BASIS_MAGIC)

return false;

return m_transcoder.get_basis_tex_format(m_file.data(), m_file.size()) == basis_tex_format::cUASTC_LDR_4x4;

}

bool isETC1S()

{

assert(m_magic == BASIS_MAGIC);

if (m_magic != BASIS_MAGIC)

return false;

return m_transcoder.get_basis_tex_format(m_file.data(), m_file.size()) == basis_tex_format::cETC1S;

}

// True for any LDR texture types

bool isLDR()

{

assert(m_magic == BASIS_MAGIC);

if (m_magic != BASIS_MAGIC)

return false;

basis_tex_format fmt = m_transcoder.get_basis_tex_format(m_file.data(), m_file.size());

return (fmt == basis_tex_format::cETC1S) || (fmt == basis_tex_format::cUASTC_LDR_4x4);

}

// True if the texture is UASTC HDR 4x4 or ASTC HDR 6x6.

// In this case, it can only be transcoded to BC6H, ASTC HDR (of the same block dimensions, currently 4x4 or 6x6), RGB9E5 or half-float RGB/RGBA images.

bool isHDR()

{

assert(m_magic == BASIS_MAGIC);

if (m_magic != BASIS_MAGIC)

return false;

basis_tex_format fmt = m_transcoder.get_basis_tex_format(m_file.data(), m_file.size());

return basis_tex_format_is_hdr(fmt);

}

bool isHDR4x4()

{

assert(m_magic == BASIS_MAGIC);

if (m_magic != BASIS_MAGIC)

return false;

basis_tex_format fmt = m_transcoder.get_basis_tex_format(m_file.data(), m_file.size());

return (fmt == basis_tex_format::cUASTC_HDR_4x4);

}

bool isHDR6x6()

{

assert(m_magic == BASIS_MAGIC);

if (m_magic != BASIS_MAGIC)

return false;

basis_tex_format fmt = m_transcoder.get_basis_tex_format(m_file.data(), m_file.size());

return (fmt == basis_tex_format::cASTC_HDR_6x6) || (fmt == basis_tex_format::cUASTC_HDR_6x6_INTERMEDIATE);

}

// True for plain ASTC LDR 4x4-12x12

bool isASTC_LDR()

{

assert(m_magic == BASIS_MAGIC);

if (m_magic != BASIS_MAGIC)

return false;

basis_tex_format fmt = m_transcoder.get_basis_tex_format(m_file.data(), m_file.size());

return basis_tex_format_is_astc_ldr(fmt);

}

// True for XUASTC LDR 4x4-12x12

bool isXUASTC_LDR()

{

assert(m_magic == BASIS_MAGIC);

if (m_magic != BASIS_MAGIC)

return false;

basis_tex_format fmt = m_transcoder.get_basis_tex_format(m_file.data(), m_file.size());

return basis_tex_format_is_xuastc_ldr(fmt);

}

bool isXUBC7()

{

assert(m_magic == BASIS_MAGIC);

if (m_magic != BASIS_MAGIC)

return false;

basis_tex_format fmt = m_transcoder.get_basis_tex_format(m_file.data(), m_file.size());

return basis_tex_format_is_xubc7(fmt);

}

uint32_t startTranscoding()

{

assert(m_magic == BASIS_MAGIC);

if (m_magic != BASIS_MAGIC)

return 0;

return m_transcoder.start_transcoding(m_file.data(), m_file.size());

}

// Here for backwards compat, prefer transcodeImageWithFlags().

// format is transcoder_texture_format

uint32_t transcodeImage(const emscripten::val& dst, uint32_t image_index, uint32_t level_index, uint32_t format, uint32_t unused, uint32_t get_alpha_for_opaque_formats)

{

(void)unused;

assert(m_magic == BASIS_MAGIC);

if (m_magic != BASIS_MAGIC)

return 0;

if (format >= (int)transcoder_texture_format::cTFTotalTextureFormats)

return 0;

const transcoder_texture_format transcoder_format = static_cast<transcoder_texture_format>(format);

uint32_t orig_width, orig_height, total_src_blocks;

if (!m_transcoder.get_image_level_desc(m_file.data(), m_file.size(), image_index, level_index, orig_width, orig_height, total_src_blocks))

return 0;

basisu::vector<uint8_t> dst_data;

uint32_t flags = get_alpha_for_opaque_formats ? cDecodeFlagsTranscodeAlphaDataToOpaqueFormats : 0;

const uint32_t transcoded_size_in_bytes = getImageTranscodedSizeInBytes(image_index, level_index, format);

if (!dst_data.try_resize(transcoded_size_in_bytes))

return 0;

uint32_t status;

if (basis_transcoder_format_is_uncompressed(transcoder_format))

{

status = m_transcoder.transcode_image_level(

m_file.data(), m_file.size(), image_index, level_index,

dst_data.data(), orig_width * orig_height,

transcoder_format,

flags,

orig_width,

nullptr,

orig_height);

}

else

{

const uint32_t bytes_per_block = basis_get_bytes_per_block_or_pixel(transcoder_format);

status = m_transcoder.transcode_image_level(

m_file.data(), m_file.size(), image_index, level_index,

dst_data.data(), dst_data.size() / bytes_per_block,

static_cast<basist::transcoder_texture_format>(format),

flags);

}

#if 0

emscripten::val memory = emscripten::val::module_property("HEAP8")["buffer"];

emscripten::val memoryView = emscripten::val::global("Uint8Array").new_(memory, reinterpret_cast<uintptr_t>(dst_data.data()), dst_data.size());

dst.call<void>("set", memoryView);

#else

if (!dst_data.empty())

{

const size_t n = dst_data.size();

emscripten::val srcView = emscripten::val(emscripten::typed_memory_view(n, dst_data.data()));

dst.call<void>("set", srcView); // 'dst' is a JS Uint8Array

}

#endif

return status;

}

// Like transcodeImage(), but with updated parameters.

// For flags, see cDecodeFlagsPVRTCDecodeToNextPow2 etc.

// format is transcoder_texture_format

uint32_t transcodeImageWithFlags(const emscripten::val& dst, uint32_t image_index, uint32_t level_index, uint32_t format, uint32_t flags)

{

assert(m_magic == BASIS_MAGIC);

if (m_magic != BASIS_MAGIC)

return 0;

if (format >= (int)transcoder_texture_format::cTFTotalTextureFormats)

return 0;

const transcoder_texture_format transcoder_format = static_cast<transcoder_texture_format>(format);

uint32_t orig_width, orig_height, total_src_blocks;

if (!m_transcoder.get_image_level_desc(m_file.data(), m_file.size(), image_index, level_index, orig_width, orig_height, total_src_blocks))

return 0;

basisu::vector<uint8_t> dst_data;

const uint32_t transcoded_size_in_bytes = getImageTranscodedSizeInBytes(image_index, level_index, format);

if (!dst_data.try_resize(transcoded_size_in_bytes))

return 0;

uint32_t status;

if (basis_transcoder_format_is_uncompressed(transcoder_format))

{

status = m_transcoder.transcode_image_level(

m_file.data(), m_file.size(), image_index, level_index,

dst_data.data(), orig_width * orig_height,

transcoder_format,

flags,

orig_width,

nullptr,

orig_height);

}

else

{

const uint32_t bytes_per_block = basis_get_bytes_per_block_or_pixel(transcoder_format);

status = m_transcoder.transcode_image_level(

m_file.data(), m_file.size(), image_index, level_index,

dst_data.data(), dst_data.size() / bytes_per_block,

static_cast<basist::transcoder_texture_format>(format),

flags);

}

#if 0

emscripten::val memory = emscripten::val::module_property("HEAP8")["buffer"];

emscripten::val memoryView = emscripten::val::global("Uint8Array").new_(memory, reinterpret_cast<uintptr_t>(dst_data.data()), dst_data.size());

dst.call<void>("set", memoryView);

#else

const size_t n = dst_data.size();

emscripten::val srcView = emscripten::val(emscripten::typed_memory_view(n, dst_data.data()));

dst.call<void>("set", srcView); // 'dst' is a JS Uint8Array

#endif

return status;

}

};

#if BASISD_SUPPORT_KTX2

struct ktx2_header_js

{

uint32_t m_vk_format;

uint32_t m_type_size;

uint32_t m_pixel_width;

uint32_t m_pixel_height;

uint32_t m_pixel_depth;

uint32_t m_layer_count;

uint32_t m_face_count;

uint32_t m_level_count;

uint32_t m_supercompression_scheme;

uint32_t m_dfd_byte_offset;

uint32_t m_dfd_byte_length;

uint32_t m_kvd_byte_offset;

uint32_t m_kvd_byte_length;

uint32_t m_sgd_byte_offset;

uint32_t m_sgd_byte_length;

};

struct ktx2_file

{

int m_magic = 0;

basist::ktx2_transcoder m_transcoder;

basisu::vector<uint8_t> m_file;

bool m_is_valid = false;

ktx2_file(const emscripten::val& jsBuffer)

: m_file(jsBuffer["byteLength"].as<size_t>())

{

if (!g_basis_initialized_flag)

{

#if BASISU_DEBUG_PRINTF

printf("basis_file::basis_file: Must call basis_init() first!\n");

#endif

assert(0);

return;

}

#if 0

unsigned int length = jsBuffer["length"].as<unsigned int>();

emscripten::val memory = emscripten::val::module_property("HEAP8")["buffer"];

emscripten::val memoryView = jsBuffer["constructor"].new_(memory, reinterpret_cast<uintptr_t>(m_file.data()), length);

memoryView.call<void>("set", jsBuffer);

#else

const size_t n = jsBuffer["byteLength"].as<size_t>();

emscripten::val dstView = emscripten::val(emscripten::typed_memory_view(n, m_file.data()));

dstView.call<void>("set", jsBuffer);

#endif

if (!m_transcoder.init(m_file.data(), m_file.size()))

{

#if BASISU_DEBUG_PRINTF

printf("m_transcoder.init() failed!\n");

#endif

assert(0);

m_file.clear();

}

m_is_valid = true;

// Initialized after validation

m_magic = KTX2_MAGIC;

}

bool isValid()

{

assert(m_magic == KTX2_MAGIC);

if (m_magic != KTX2_MAGIC)

return false;

return m_is_valid;

}

void close()

{

assert(m_magic == KTX2_MAGIC);

if (m_magic != KTX2_MAGIC)

return;

m_file.clear();

m_transcoder.clear();

}

uint32_t getDFDSize()

{

return m_transcoder.get_dfd().size();

}

uint32_t getDFD(const emscripten::val& dst)

{

assert(m_magic == KTX2_MAGIC);

if (m_magic != KTX2_MAGIC)

return 0;

const uint8_vec &dst_data = m_transcoder.get_dfd();

if (dst_data.size())

return copy_to_jsbuffer(dst, dst_data);

return 1;

}

ktx2_header_js getHeader()

{

ktx2_header_js hdr;

memset(&hdr, 0, sizeof(hdr));

assert(m_magic == KTX2_MAGIC);

if (m_magic != KTX2_MAGIC)

return hdr;

const basist::ktx2_header& h = m_transcoder.get_header();

if ((h.m_sgd_byte_offset.get_uint64() > UINT32_MAX) || (h.m_sgd_byte_length.get_uint64() > UINT32_MAX))

{

// File is too large to handle with 32-bit WASM.

// (emscripten doesn't support binding uint64_t for some reason.)

assert(0);

return hdr;

}

hdr.m_vk_format = h.m_vk_format;

hdr.m_type_size = h.m_type_size;

hdr.m_pixel_width = h.m_pixel_width;

hdr.m_pixel_height = h.m_pixel_height;

hdr.m_pixel_depth = h.m_pixel_depth;

hdr.m_layer_count = h.m_layer_count;

hdr.m_face_count = h.m_face_count;

hdr.m_level_count = h.m_level_count;

hdr.m_supercompression_scheme = h.m_supercompression_scheme;

hdr.m_dfd_byte_offset = h.m_dfd_byte_offset;

hdr.m_dfd_byte_length = h.m_dfd_byte_length;

hdr.m_kvd_byte_offset = h.m_kvd_byte_offset;

hdr.m_kvd_byte_length = h.m_kvd_byte_length;

hdr.m_sgd_byte_offset = static_cast<uint32_t>(h.m_sgd_byte_offset.get_uint64());

hdr.m_sgd_byte_length = static_cast<uint32_t>(h.m_sgd_byte_length.get_uint64());

return hdr;

}

bool hasKey(std::string key_name)

{

assert(m_magic == KTX2_MAGIC);

if (m_magic != KTX2_MAGIC)

return false;

return m_transcoder.find_key(key_name) != nullptr;

}

uint32_t getTotalKeys()

{

assert(m_magic == KTX2_MAGIC);

if (m_magic != KTX2_MAGIC)

return 0;

return m_transcoder.get_key_values().size();

}

std::string getKey(uint32_t index)

{

assert(m_magic == KTX2_MAGIC);

if (m_magic != KTX2_MAGIC)

return std::string("");

return std::string((const char*)m_transcoder.get_key_values()[index].m_key.data());

}

uint32_t getKeyValueSize(std::string key_name)

{

assert(m_magic == KTX2_MAGIC);

if (m_magic != KTX2_MAGIC)

return 0;

const uint8_vec* p = m_transcoder.find_key(key_name);

return p ? p->size() : 0;

}

uint32_t getKeyValue(std::string key_name, const emscripten::val& dst)

{

assert(m_magic == KTX2_MAGIC);

if (m_magic != KTX2_MAGIC)

return 0;

const uint8_vec* p = m_transcoder.find_key(key_name);

if (!p)

return 0;

if (p->size())

return copy_to_jsbuffer(dst, *p);

return 1;

}

// The image's original width, i.e. before being potentially expanded up to blocks.

uint32_t getWidth()

{

assert(m_magic == KTX2_MAGIC);

if (m_magic != KTX2_MAGIC)

return 0;

return m_transcoder.get_width();

}

// The image's original height, i.e. before being potentially expanded up to blocks.

uint32_t getHeight()

{

assert(m_magic == KTX2_MAGIC);

if (m_magic != KTX2_MAGIC)

return 0;

return m_transcoder.get_height();

}

// 4-12

uint32_t getBlockWidth()

{

assert(m_magic == KTX2_MAGIC);

if (m_magic != KTX2_MAGIC)

return 0;

return m_transcoder.get_block_width();

}

// 4-12

uint32_t getBlockHeight()

{

assert(m_magic == KTX2_MAGIC);

if (m_magic != KTX2_MAGIC)

return 0;

return m_transcoder.get_block_height();

}

// 2D or cubemaps

uint32_t getFaces()

{

assert(m_magic == KTX2_MAGIC);

if (m_magic != KTX2_MAGIC)

return 0;

return m_transcoder.get_faces();

}

// Layers for tex arrays

uint32_t getLayers()