From 2ee4332a1dcc6a4376c7f77f7112c0ead3bf3424 Mon Sep 17 00:00:00 2001
From: Marco Hutter <github@marco-hutter.de>
Date: Sat, 14 Sep 2024 05:03:16 +0200
Subject: [PATCH] JNI improvements (#886)

Large refactoring of the Java Wrapper, focussing on error handling,
documentation, completeness, and usability improvements. Fixes #880.

This includes several breaking changes. Not all breaking changes are listed
here explicitly. But in all cases, it should be easy for clients to update
their code to the new state. The most important changes for the Java
Wrapper are:

- Made `deflateZstd`, `deflateZLIB`, and `createFromMemory` available
  in the `KtxTexture2` class
- Fixed a bug where the `KtxBasisParams#setInputSwizzle` function caused
  data corruption
- Increased the consistency of the naming and handling of constants:
  - All constant names are `UPPER_SNAKE_CASE`, omitting common prefixes
  - Classes that define constants offer a `stringFor` function that returns the
    string representation of a constant
  - The `KtxCreateStorage` class was renamed to `KtxTextureCreateStorage`
  - The `KtxPackUASTCFlagBits` class was renamed to `KtxPackUastcFlagBits`
- Improved error handling:
  - When functions receive a parameter that is `null`, then this will no longer
    crash the JVM, but throw a `NullPointerException` instead
  - When `setInputSwizzle` receives invalid arguments, then an
    `IllegalArgumentException` will be thrown
  - When one of the `create...` family of functions causes an error, meaning
    that the respective `KtxTexture2` object cannot be created, then a
    `KtxException` will be thrown
- Added JavaDocs, and enabled the generation of JavaDocs as part of the Maven build process
- Internal improvements (like JNI field caching, and avoiding to call JNI functions with pending exceptions)
---
 interface/java_binding/CMakeLists.txt         |   1 +
 interface/java_binding/pom.xml                |  13 +
 .../src/main/cpp/KtxErrorCode.cpp             |  19 +
 .../java_binding/src/main/cpp/KtxTexture.cpp  | 222 ++++-
 .../java_binding/src/main/cpp/KtxTexture1.cpp |  52 +-
 .../java_binding/src/main/cpp/KtxTexture2.cpp | 198 +++-
 .../java_binding/src/main/cpp/libktx-jni.cpp  | 477 ++++++---
 .../java_binding/src/main/cpp/libktx-jni.h    | 104 +-
 .../java/org/khronos/ktx/KhrDfTransfer.java   | 177 ++++
 .../java/org/khronos/ktx/KtxAstcParams.java   | 329 +++++--
 .../java/org/khronos/ktx/KtxBasisParams.java  | 904 ++++++++++++++----
 .../org/khronos/ktx/KtxCreateStorage.java     |  11 -
 .../java/org/khronos/ktx/KtxErrorCode.java    | 210 +++-
 .../java/org/khronos/ktx/KtxException.java    |  43 +
 .../org/khronos/ktx/KtxInternalformat.java    |   5 +
 .../ktx/KtxPackAstcBlockDimension.java        | 145 +++
 .../khronos/ktx/KtxPackAstcEncoderMode.java   |  31 +
 .../khronos/ktx/KtxPackAstcQualityLevel.java  |  62 +-
 .../org/khronos/ktx/KtxPackUASTCFlagBits.java |  22 -
 .../org/khronos/ktx/KtxPackUastcFlagBits.java | 139 +++
 .../org/khronos/ktx/KtxSupercmpScheme.java    |  52 +
 .../main/java/org/khronos/ktx/KtxTexture.java | 319 ++++--
 .../java/org/khronos/ktx/KtxTexture1.java     | 134 ++-
 .../java/org/khronos/ktx/KtxTexture2.java     | 389 ++++++--
 .../khronos/ktx/KtxTextureCreateFlagBits.java |  80 +-
 .../org/khronos/ktx/KtxTextureCreateInfo.java | 393 ++++++--
 .../khronos/ktx/KtxTextureCreateStorage.java  |  47 +
 .../org/khronos/ktx/KtxTranscodeFlagBits.java |  80 ++
 .../org/khronos/ktx/KtxTranscodeFormat.java   | 204 +++-
 .../khronos/ktx/test/KtxAstcParamsTest.java   |  46 +
 .../org/khronos/ktx/test/KtxParallelTest.java |   4 +-
 .../ktx/test/KtxTestLibraryLoader.java        | 150 ++-
 .../org/khronos/ktx/test/KtxTexture1Test.java |   2 +-
 .../org/khronos/ktx/test/KtxTexture2Test.java | 454 +++++++--
 lib/strings.c                                 |   2 +-
 35 files changed, 4565 insertions(+), 955 deletions(-)
 create mode 100644 interface/java_binding/src/main/cpp/KtxErrorCode.cpp
 create mode 100644 interface/java_binding/src/main/java/org/khronos/ktx/KhrDfTransfer.java
 delete mode 100644 interface/java_binding/src/main/java/org/khronos/ktx/KtxCreateStorage.java
 create mode 100644 interface/java_binding/src/main/java/org/khronos/ktx/KtxException.java
 delete mode 100644 interface/java_binding/src/main/java/org/khronos/ktx/KtxPackUASTCFlagBits.java
 create mode 100644 interface/java_binding/src/main/java/org/khronos/ktx/KtxPackUastcFlagBits.java
 create mode 100644 interface/java_binding/src/main/java/org/khronos/ktx/KtxTextureCreateStorage.java
 create mode 100644 interface/java_binding/src/main/java/org/khronos/ktx/KtxTranscodeFlagBits.java
 create mode 100644 interface/java_binding/src/test/java/org/khronos/ktx/test/KtxAstcParamsTest.java

diff --git a/interface/java_binding/CMakeLists.txt b/interface/java_binding/CMakeLists.txt
index 0716119a46..1920b83856 100644
--- a/interface/java_binding/CMakeLists.txt
+++ b/interface/java_binding/CMakeLists.txt
@@ -28,6 +28,7 @@ add_library(ktx-jni SHARED
     src/main/cpp/KtxTexture.cpp
     src/main/cpp/KtxTexture1.cpp
     src/main/cpp/KtxTexture2.cpp
+    src/main/cpp/KtxErrorCode.cpp
     src/main/cpp/libktx-jni.cpp
     ${CMAKE_CURRENT_BINARY_DIR}/ktx-jni.manifest
 )
diff --git a/interface/java_binding/pom.xml b/interface/java_binding/pom.xml
index a6df16d9c0..5d6536ac04 100644
--- a/interface/java_binding/pom.xml
+++ b/interface/java_binding/pom.xml
@@ -144,6 +144,19 @@
           </execution>
         </executions>
       </plugin>
+      <plugin>
+        <groupId>org.apache.maven.plugins</groupId>
+        <artifactId>maven-javadoc-plugin</artifactId>
+        <version>3.6.3</version>
+        <executions>
+          <execution>
+            <id>attach-javadocs</id>
+            <goals>
+              <goal>jar</goal>
+            </goals>
+          </execution>
+        </executions>
+      </plugin>
       <!--
       <plugin>
         <groupId>org.codehaus.mojo</groupId>
diff --git a/interface/java_binding/src/main/cpp/KtxErrorCode.cpp b/interface/java_binding/src/main/cpp/KtxErrorCode.cpp
new file mode 100644
index 0000000000..f91262f041
--- /dev/null
+++ b/interface/java_binding/src/main/cpp/KtxErrorCode.cpp
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2024, Khronos Group and Contributors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#include "libktx-jni.h"
+#include <iostream>
+
+extern "C" JNIEXPORT jstring JNICALL Java_org_khronos_ktx_KtxErrorCode_createString(JNIEnv *env, jclass, jint error)
+{
+  KTX_error_code errorNative = KTX_error_code(error);
+  const char* errorStringNative = ktxErrorString(errorNative);
+
+  // If this causes an OutOfMemoryError, then it will return
+  // 'null', with the OutOfMemoryError pending
+  jstring errorString = env->NewStringUTF(errorStringNative);
+  return errorString;
+}
+
diff --git a/interface/java_binding/src/main/cpp/KtxTexture.cpp b/interface/java_binding/src/main/cpp/KtxTexture.cpp
index b5dbeb7c15..0a6028f613 100644
--- a/interface/java_binding/src/main/cpp/KtxTexture.cpp
+++ b/interface/java_binding/src/main/cpp/KtxTexture.cpp
@@ -1,5 +1,6 @@
 /*
  * Copyright (c) 2021, Shukant Pal and Contributors
+ * Copyright (c) 2024, Khronos Group and Contributors
  * SPDX-License-Identifier: Apache-2.0
  */
 
@@ -15,62 +16,133 @@
 
 extern "C" JNIEXPORT jboolean JNICALL Java_org_khronos_ktx_KtxTexture_isArray(JNIEnv *env, jobject thiz)
 {
-    return get_ktx_texture(env, thiz)->isArray;
+    ktxTexture *texture = get_ktx_texture(env, thiz);
+    if (texture == NULL) 
+    {
+      ThrowDestroyed(env);
+      return false;
+    }
+    return texture->isArray;
 }
 
 extern "C" JNIEXPORT jboolean JNICALL Java_org_khronos_ktx_KtxTexture_isCubemap(JNIEnv *env, jobject thiz)
 {
-    return get_ktx_texture(env, thiz)->isCubemap;
+    ktxTexture *texture = get_ktx_texture(env, thiz);
+    if (texture == NULL) 
+    {
+      ThrowDestroyed(env);
+      return false;
+    }
+    return texture->isCubemap;
 }
 
 extern "C" JNIEXPORT jboolean JNICALL Java_org_khronos_ktx_KtxTexture_isCompressed(JNIEnv *env, jobject thiz)
 {
-    return get_ktx_texture(env, thiz)->isCompressed;
+    ktxTexture *texture = get_ktx_texture(env, thiz);
+    if (texture == NULL) 
+    {
+      ThrowDestroyed(env);
+      return false;
+    }
+    return texture->isCompressed;
 }
 
 extern "C" JNIEXPORT jboolean JNICALL Java_org_khronos_ktx_KtxTexture_getGenerateMipmaps(JNIEnv *env, jobject thiz)
 {
-    return get_ktx_texture(env, thiz)->generateMipmaps;
+    ktxTexture *texture = get_ktx_texture(env, thiz);
+    if (texture == NULL) 
+    {
+      ThrowDestroyed(env);
+      return false;
+    }
+    return texture->generateMipmaps;
 }
 
 extern "C" JNIEXPORT jint JNICALL Java_org_khronos_ktx_KtxTexture_getBaseWidth(JNIEnv *env, jobject thiz)
 {
-    return get_ktx_texture(env, thiz)->baseWidth;
+    ktxTexture *texture = get_ktx_texture(env, thiz);
+    if (texture == NULL) 
+    {
+      ThrowDestroyed(env);
+      return 0;
+    }
+    return texture->baseWidth;
 }
 
 extern "C" JNIEXPORT jint JNICALL Java_org_khronos_ktx_KtxTexture_getBaseHeight(JNIEnv *env, jobject thiz)
 {
-    return get_ktx_texture(env, thiz)->baseHeight;
+    ktxTexture *texture = get_ktx_texture(env, thiz);
+    if (texture == NULL) 
+    {
+      ThrowDestroyed(env);
+      return 0;
+    }
+    return texture->baseHeight;
 }
 
 extern "C" JNIEXPORT jint JNICALL Java_org_khronos_ktx_KtxTexture_getBaseDepth(JNIEnv *env, jobject thiz)
 {
-    return get_ktx_texture(env, thiz)->baseDepth;
+    ktxTexture *texture = get_ktx_texture(env, thiz);
+    if (texture == NULL) 
+    {
+      ThrowDestroyed(env);
+      return 0;
+    }
+    return texture->baseDepth;
 }
 
 extern "C" JNIEXPORT jint JNICALL Java_org_khronos_ktx_KtxTexture_getNumDimensions(JNIEnv *env, jobject thiz)
 {
-    return get_ktx_texture(env, thiz)->numDimensions;
+    ktxTexture *texture = get_ktx_texture(env, thiz);
+    if (texture == NULL) 
+    {
+      ThrowDestroyed(env);
+      return 0;
+    }
+    return texture->numDimensions;
 }
 
 extern "C" JNIEXPORT jint JNICALL Java_org_khronos_ktx_KtxTexture_getNumLevels(JNIEnv *env, jobject thiz)
 {
-    return get_ktx_texture(env, thiz)->numLevels;
+    ktxTexture *texture = get_ktx_texture(env, thiz);
+    if (texture == NULL) 
+    {
+      ThrowDestroyed(env);
+      return 0;
+    }
+    return texture->numLevels;
 }
 
 extern "C" JNIEXPORT jint JNICALL Java_org_khronos_ktx_KtxTexture_getNumLayers(JNIEnv *env, jobject thiz)
 {
-    return get_ktx_texture(env, thiz)->numLayers;
+    ktxTexture *texture = get_ktx_texture(env, thiz);
+    if (texture == NULL) 
+    {
+      ThrowDestroyed(env);
+      return 0;
+    }
+    return texture->numLayers;
 }
 
 extern "C" JNIEXPORT jint JNICALL Java_org_khronos_ktx_KtxTexture_getNumFaces(JNIEnv *env, jobject thiz)
 {
-    return get_ktx_texture(env, thiz)->numFaces;
+    ktxTexture *texture = get_ktx_texture(env, thiz);
+    if (texture == NULL) 
+    {
+      ThrowDestroyed(env);
+      return 0;
+    }
+    return texture->numFaces;
 }
 
 extern "C" JNIEXPORT jbyteArray JNICALL Java_org_khronos_ktx_KtxTexture_getData(JNIEnv *env, jobject thiz)
 {
     ktxTexture *texture = get_ktx_texture(env, thiz);
+    if (texture == NULL) 
+    {
+      ThrowDestroyed(env);
+      return NULL;
+    }
     ktx_uint8_t *data = ktxTexture_GetData(texture);
 
     if (data == NULL) {
@@ -80,11 +152,17 @@ extern "C" JNIEXPORT jbyteArray JNICALL Java_org_khronos_ktx_KtxTexture_getData(
     ktx_size_t dataSize = ktxTexture_GetDataSize(texture);
 
     if (dataSize >= UINT32_MAX) {
-        std::cout << "getData array too large for Java" << std::endl;
+        ThrowByName(env, "java/lang/UnsupportedOperationException", "The array returned by getData is too large for a Java array");
         return NULL;
     }
 
     jbyteArray outputArray = env->NewByteArray(static_cast<jsize>(dataSize));
+    if (outputArray == NULL) 
+    {
+      // OutOfMemoryError is already pending
+      return NULL;
+    }
+
     jsize outputLength = env->GetArrayLength(outputArray);
 
     if ((ktx_size_t) outputLength != dataSize) {
@@ -101,31 +179,61 @@ extern "C" JNIEXPORT jbyteArray JNICALL Java_org_khronos_ktx_KtxTexture_getData(
 
 extern "C" JNIEXPORT jlong JNICALL Java_org_khronos_ktx_KtxTexture_getDataSize(JNIEnv *env, jobject thiz)
 {
-    return static_cast<jlong>(ktxTexture_GetDataSize(get_ktx_texture(env, thiz)));
+    ktxTexture *texture = get_ktx_texture(env, thiz);
+    if (texture == NULL) 
+    {
+      ThrowDestroyed(env);
+      return 0;
+    }
+    return static_cast<jlong>(ktxTexture_GetDataSize(texture));
 }
 
 extern "C" JNIEXPORT jlong JNICALL Java_org_khronos_KTXTexture_getDataSizeUncompressed(JNIEnv *env, jobject thiz)
 {
-    return ktxTexture_GetDataSizeUncompressed(get_ktx_texture(env, thiz));
+    ktxTexture *texture = get_ktx_texture(env, thiz);
+    if (texture == NULL) 
+    {
+      ThrowDestroyed(env);
+      return 0;
+    }
+    return ktxTexture_GetDataSizeUncompressed(texture);
 }
 
 extern "C" JNIEXPORT jint JNICALL Java_org_khronos_ktx_KtxTexture_getElementSize(JNIEnv *env, jobject thiz)
 {
-    return static_cast<jint>(ktxTexture_GetElementSize(get_ktx_texture(env, thiz)));
+    ktxTexture *texture = get_ktx_texture(env, thiz);
+    if (texture == NULL) 
+    {
+      ThrowDestroyed(env);
+      return 0;
+    }
+    return static_cast<jint>(ktxTexture_GetElementSize(texture));
 }
 
 extern "C" JNIEXPORT jint JNICALL Java_org_khronos_ktx_KtxTexture_getRowPitch(JNIEnv *env,
                                                                             jobject thiz,
                                                                             jint level)
 {
-    return static_cast<jint>(ktxTexture_GetRowPitch(get_ktx_texture(env, thiz), level));
+    ktxTexture *texture = get_ktx_texture(env, thiz);
+    if (texture == NULL) 
+    {
+      ThrowDestroyed(env);
+      return 0;
+    }
+    return static_cast<jint>(ktxTexture_GetRowPitch(texture, level));
 }
 
 extern "C" JNIEXPORT jlong JNICALL Java_org_khronos_ktx_KtxTexture_getImageSize(JNIEnv *env,
                                                                             jobject thiz,
                                                                             jint level)
 {
-    return ktxTexture_GetImageSize(get_ktx_texture(env, thiz), level);
+    ktxTexture *texture = get_ktx_texture(env, thiz);
+    if (texture == NULL) 
+    {
+      ThrowDestroyed(env);
+      return 0;
+    }
+    return ktxTexture_GetImageSize(texture, level);
 }
 
 extern "C" JNIEXPORT jlong JNICALL Java_org_khronos_ktx_KtxTexture_getImageOffset(JNIEnv *env,
@@ -134,8 +242,15 @@ extern "C" JNIEXPORT jlong JNICALL Java_org_khronos_ktx_KtxTexture_getImageOffse
                                                                             jint layer,
                                                                             jint faceSlice)
 {
+    ktxTexture *texture = get_ktx_texture(env, thiz);
+    if (texture == NULL) 
+    {
+      ThrowDestroyed(env);
+      return 0;
+    }
+
     ktx_size_t pOffset = 0;
-    KTX_error_code result = ktxTexture_GetImageOffset(get_ktx_texture(env, thiz),
+    KTX_error_code result = ktxTexture_GetImageOffset(texture,
                                                         level,
                                                         layer,
                                                         faceSlice,
@@ -149,8 +264,14 @@ extern "C" JNIEXPORT jlong JNICALL Java_org_khronos_ktx_KtxTexture_getImageOffse
 
 extern "C" JNIEXPORT void JNICALL Java_org_khronos_ktx_KtxTexture_destroy(JNIEnv *env, jobject thiz)
 {
-    ktxTexture_Destroy(get_ktx_texture(env, thiz));
-    set_ktx_texture(env, thiz, NULL);
+    // Calling 'destroy' on an already destroyed texture 
+    // should be OK, but have no effect
+    ktxTexture *texture = get_ktx_texture(env, thiz);
+    if (texture != NULL) 
+    {
+        ktxTexture_Destroy(get_ktx_texture(env, thiz));
+        set_ktx_texture(env, thiz, NULL);
+    }
 }
 
 extern "C" JNIEXPORT jint JNICALL Java_org_khronos_ktx_KtxTexture_setImageFromMemory(JNIEnv *env,
@@ -160,10 +281,29 @@ extern "C" JNIEXPORT jint JNICALL Java_org_khronos_ktx_KtxTexture_setImageFromMe
                                                                                     jint faceSlice,
                                                                                     jbyteArray srcArray)
 {
-    ktx_uint8_t *src = reinterpret_cast<ktx_uint8_t*>(env->GetByteArrayElements(srcArray, NULL));
+    if (srcArray == NULL) 
+    {
+      ThrowByName(env, "java/lang/NullPointerException", "Parameter 'srcArray' is null for setImageFromMemory");
+      return 0;
+    }
+    ktxTexture *texture = get_ktx_texture(env, thiz);
+    if (texture == NULL) 
+    {
+      ThrowDestroyed(env);
+      return 0;
+    }
+
+    jbyte* srcArrayElements = env->GetByteArrayElements(srcArray, NULL);
+    if (srcArrayElements == NULL) 
+    {
+      // OutOfMemoryError is already pending
+      return 0;
+    }
+
+    ktx_uint8_t *src = reinterpret_cast<ktx_uint8_t*>(srcArrayElements);
     ktx_size_t srcSize = static_cast<ktx_size_t>(env->GetArrayLength(srcArray));
 
-    jint result = ktxTexture_SetImageFromMemory(get_ktx_texture(env, thiz),
+    jint result = ktxTexture_SetImageFromMemory(texture,
                                 level,
                                 layer,
                                 faceSlice,
@@ -179,9 +319,27 @@ extern "C" JNIEXPORT jint JNICALL Java_org_khronos_ktx_KtxTexture_writeToNamedFi
                                                                                     jobject thiz,
                                                                                     jstring dstName)
 {
+    if (dstName == NULL) 
+    {
+      ThrowByName(env, "java/lang/NullPointerException", "Parameter 'dstName' is null for writeToNamedFile");
+      return 0;
+    }
+    ktxTexture *texture = get_ktx_texture(env, thiz);
+    if (texture == NULL) 
+    {
+      ThrowDestroyed(env);
+      return 0;
+    }
+
     const char *dstNameArray = env->GetStringUTFChars(dstName, NULL);
+    if (dstNameArray == NULL) 
+    {
+      // OutOfMemoryError is already pending
+      return 0;
+    }
 
-    jint result = ktxTexture_WriteToNamedFile(get_ktx_texture(env, thiz), dstNameArray);
+
+    jint result = ktxTexture_WriteToNamedFile(texture, dstNameArray);
 
     env->ReleaseStringUTFChars(dstName, dstNameArray);
 
@@ -191,21 +349,33 @@ extern "C" JNIEXPORT jint JNICALL Java_org_khronos_ktx_KtxTexture_writeToNamedFi
 extern "C" JNIEXPORT jbyteArray JNICALL Java_org_khronos_ktx_KtxTexture_writeToMemory(JNIEnv *env,
                                                                                     jobject thiz)
 {
+    ktxTexture *texture = get_ktx_texture(env, thiz);
+    if (texture == NULL) 
+    {
+      ThrowDestroyed(env);
+      return 0;
+    }
+
     ktx_uint8_t *ppDstBytes;
     ktx_size_t pSize;
-    KTX_error_code result = ktxTexture_WriteToMemory(get_ktx_texture(env, thiz), &ppDstBytes, &pSize);
+    KTX_error_code result = ktxTexture_WriteToMemory(texture, &ppDstBytes, &pSize);
 
     if (result != KTX_SUCCESS) {
-        std::cout << "Failed to writeToMemory KTXTexture, error " << result << std::endl;
+        ThrowByName(env, "org/khronos/ktx/KtxException", ktxErrorString(result));
         return NULL;
     }
     if (pSize >= UINT32_MAX) {
-        std::cout << "writeToMemory array is too large for Java" << std::endl;
         delete ppDstBytes;// make sure to delete it
+        ThrowByName(env, "java/lang/UnsupportedOperationException", "The array created by by writeToMemory is too large for a Java array");
         return NULL;
     }
 
     jbyteArray out = env->NewByteArray(static_cast<jsize>(pSize));
+    if (out == NULL) 
+    {
+      // OutOfMemoryError is already pending
+      return NULL;
+    }
 
     env->SetByteArrayRegion(out,
                             0,
diff --git a/interface/java_binding/src/main/cpp/KtxTexture1.cpp b/interface/java_binding/src/main/cpp/KtxTexture1.cpp
index a2d7811764..f02658ccf4 100644
--- a/interface/java_binding/src/main/cpp/KtxTexture1.cpp
+++ b/interface/java_binding/src/main/cpp/KtxTexture1.cpp
@@ -1,5 +1,6 @@
 /*
  * Copyright (c) 2021, Shukant Pal and Contributors
+ * Copyright (c) 2024, Khronos Group and Contributors
  * SPDX-License-Identifier: Apache-2.0
  */
 
@@ -10,19 +11,37 @@
 extern "C" JNIEXPORT jint JNICALL Java_org_khronos_ktx_KtxTexture1_getGlFormat(JNIEnv *env,
                                                                                 jobject thiz)
 {
-    return get_ktx1_texture(env, thiz)->glFormat;
+    ktxTexture1 *texture = get_ktx1_texture(env, thiz);
+    if (texture == NULL) 
+    {
+      ThrowDestroyed(env);
+      return 0;
+    }
+    return texture->glFormat;
 }
 
 extern "C" JNIEXPORT jint JNICALL Java_org_khronos_ktx_KtxTexture1_getGlInternalformat(JNIEnv *env,
                                                                                 jobject thiz)
 {
-    return get_ktx1_texture(env, thiz)->glInternalformat;
+    ktxTexture1 *texture = get_ktx1_texture(env, thiz);
+    if (texture == NULL) 
+    {
+      ThrowDestroyed(env);
+      return 0;
+    }
+    return texture->glInternalformat;
 }
 
 extern "C" JNIEXPORT jint JNICALL Java_org_khronos_ktx_KtxTexture1_getGlBaseInternalformat(JNIEnv *env,
                                                                                 jobject thiz)
 {
-    return get_ktx1_texture(env, thiz)->glBaseInternalformat;
+    ktxTexture1 *texture = get_ktx1_texture(env, thiz);
+    if (texture == NULL) 
+    {
+      ThrowDestroyed(env);
+      return 0;
+    }
+    return texture->glBaseInternalformat;
 }
 
 extern "C" JNIEXPORT jobject JNICALL Java_org_khronos_ktx_KtxTexture1_create(JNIEnv *env,
@@ -30,20 +49,25 @@ extern "C" JNIEXPORT jobject JNICALL Java_org_khronos_ktx_KtxTexture1_create(JNI
                                                                                 jobject java_create_info,
                                                                                 jint storageAllocation)
 {
+    if (java_create_info == NULL) 
+    {
+      ThrowByName(env, "java/lang/NullPointerException", "Parameter 'java_create_info' is null for create");
+      return NULL;
+    }
+
     ktxTextureCreateInfo info;
     copy_ktx_texture_create_info(env, java_create_info, info);
 
     ktxTexture1 *instance = NULL;
-    KTX_error_code result;
 
     ktxTextureCreateStorageEnum storage_alloc = static_cast<ktxTextureCreateStorageEnum>(storageAllocation);
-    result = ktxTexture1_Create(&info, storage_alloc, &instance);
+    KTX_error_code result = ktxTexture1_Create(&info, storage_alloc, &instance);
 
     assert (instance != NULL);
 
     if (result != KTX_SUCCESS)
     {
-        std::cout << "Failure to create Ktx1Texture, error " << result << std::endl;
+        ThrowByName(env, "org/khronos/ktx/KtxException", ktxErrorString(result));
         return NULL;
     }
 
@@ -55,13 +79,25 @@ extern "C" JNIEXPORT jobject JNICALL Java_org_khronos_ktx_KtxTexture1_createFrom
                                                                                             jstring filename,
                                                                                             jint createFlags)
 {
+    if (filename == NULL) 
+    {
+      ThrowByName(env, "java/lang/NullPointerException", "Parameter 'filename' is null for createFromNamedFile");
+      return NULL;
+    }
+
     const char *filenameArray = env->GetStringUTFChars(filename, NULL);
+    if (filenameArray == NULL) 
+    {
+      // OutOfMemoryError is already pending
+      return NULL;
+    }
+
     ktxTexture1 *instance = NULL;
 
-    jint result = ktxTexture1_CreateFromNamedFile(filenameArray, createFlags, &instance);
+    ktx_error_code_e result = ktxTexture1_CreateFromNamedFile(filenameArray, createFlags, &instance);
 
     if (result != KTX_SUCCESS) {
-        std::cout << "Failure to createFromNamedFile Ktx1Texture, error " << result << std::endl;
+        ThrowByName(env, "org/khronos/ktx/KtxException", ktxErrorString(result));
         return NULL;
     }
 
diff --git a/interface/java_binding/src/main/cpp/KtxTexture2.cpp b/interface/java_binding/src/main/cpp/KtxTexture2.cpp
index 5e6f5a1433..46fe928d10 100644
--- a/interface/java_binding/src/main/cpp/KtxTexture2.cpp
+++ b/interface/java_binding/src/main/cpp/KtxTexture2.cpp
@@ -1,5 +1,6 @@
 /*
  * Copyright (c) 2021, Shukant Pal and Contributors
+ * Copyright (c) 2024, Khronos Group and Contributors
  * SPDX-License-Identifier: Apache-2.0
  */
 
@@ -9,64 +10,135 @@
 
 extern "C" JNIEXPORT jint JNICALL Java_org_khronos_ktx_KtxTexture2_getOETF(JNIEnv *env, jobject thiz)
 {
-    return ktxTexture2_GetOETF(get_ktx2_texture(env, thiz));
+    ktxTexture2 *texture = get_ktx2_texture(env, thiz);
+    if (texture == NULL) 
+    {
+      ThrowDestroyed(env);
+      return 0;
+    }
+    return ktxTexture2_GetOETF(texture);
 }
 
 extern "C" JNIEXPORT jboolean JNICALL Java_org_khronos_ktx_KtxTexture2_getPremultipliedAlpha(JNIEnv *env, jobject thiz)
 {
-    return ktxTexture2_GetPremultipliedAlpha(get_ktx2_texture(env, thiz));
+    ktxTexture2 *texture = get_ktx2_texture(env, thiz);
+    if (texture == NULL) 
+    {
+      ThrowDestroyed(env);
+      return 0;
+    }
+    return ktxTexture2_GetPremultipliedAlpha(texture);
 }
 
 extern "C" JNIEXPORT jboolean JNICALL Java_org_khronos_ktx_KtxTexture2_needsTranscoding(JNIEnv *env, jobject thiz)
 {
-    return ktxTexture2_NeedsTranscoding(get_ktx2_texture(env, thiz));
+    ktxTexture2 *texture = get_ktx2_texture(env, thiz);
+    if (texture == NULL) 
+    {
+      ThrowDestroyed(env);
+      return false;
+    }
+    return ktxTexture2_NeedsTranscoding(texture);
 }
 
 extern "C" JNIEXPORT jint JNICALL Java_org_khronos_ktx_KtxTexture2_getVkFormat(JNIEnv *env, jobject thiz)
 {
-    return get_ktx2_texture(env, thiz)->vkFormat;
+    ktxTexture2 *texture = get_ktx2_texture(env, thiz);
+    if (texture == NULL) 
+    {
+      ThrowDestroyed(env);
+      return 0;
+    }
+    return texture->vkFormat;
 }
 
 extern "C" JNIEXPORT jint JNICALL Java_org_khronos_ktx_KtxTexture2_getSupercompressionScheme(JNIEnv *env, jobject thiz)
 {
-    return get_ktx2_texture(env, thiz)->supercompressionScheme;
+    ktxTexture2 *texture = get_ktx2_texture(env, thiz);
+    if (texture == NULL) 
+    {
+      ThrowDestroyed(env);
+      return 0;
+    }
+    return texture->supercompressionScheme;
 }
 
 extern "C" JNIEXPORT jint JNICALL Java_org_khronos_ktx_KtxTexture2_compressAstcEx(JNIEnv *env,
                                                                                 jobject thiz,
                                                                                 jobject jparams)
 {
+    if (jparams == NULL) 
+    {
+      ThrowByName(env, "java/lang/NullPointerException", "Parameter 'jparams' is null for compressAstcEx");
+      return 0;
+    }
+    ktxTexture2 *texture = get_ktx2_texture(env, thiz);
+    if (texture == NULL) 
+    {
+      ThrowDestroyed(env);
+      return 0;
+    }
+
     ktxAstcParams params = {};
-    copy_ktx_astc_params(env, jparams, params);
+    if (!copy_ktx_astc_params(env, jparams, params)) 
+    {
+        // Exception is already pending
+        return 0;
+    }
 
-    return ktxTexture2_CompressAstcEx(get_ktx2_texture(env, thiz),
-                                        &params);
+    return ktxTexture2_CompressAstcEx(texture, &params);
 }
 
 extern "C" JNIEXPORT jint JNICALL Java_org_khronos_ktx_KtxTexture2_compressAstc(JNIEnv *env,
                                                                                 jobject thiz,
                                                                                 jint quality)
 {
-    return ktxTexture2_CompressAstc(get_ktx2_texture(env, thiz),
-                                        static_cast<uint32_t>(quality));
+    ktxTexture2 *texture = get_ktx2_texture(env, thiz);
+    if (texture == NULL) 
+    {
+      ThrowDestroyed(env);
+      return 0;
+    }
+    return ktxTexture2_CompressAstc(texture, static_cast<uint32_t>(quality));
 }
 
 extern "C" JNIEXPORT jint JNICALL Java_org_khronos_ktx_KtxTexture2_compressBasisEx(JNIEnv *env,
                                                                                 jobject thiz,
                                                                                 jobject jparams)
 {
+    if (jparams == NULL) 
+    {
+      ThrowByName(env, "java/lang/NullPointerException", "Parameter 'jparams' is null for compressBasisEx");
+      return 0;
+    }
+    ktxTexture2 *texture = get_ktx2_texture(env, thiz);
+    if (texture == NULL) 
+    {
+      ThrowDestroyed(env);
+      return 0;
+    }
+
     ktxBasisParams params = {};
-    copy_ktx_basis_params(env, jparams, params);
+    if (!copy_ktx_basis_params(env, jparams, params)) 
+    {
+        // Exception is already pending
+        return 0;
+    }
 
-    return ktxTexture2_CompressBasisEx(get_ktx2_texture(env, thiz),
-                                        &params);
+    return ktxTexture2_CompressBasisEx(texture, &params);
 }
 
 extern "C" JNIEXPORT jint JNICALL Java_org_khronos_ktx_KtxTexture2_compressBasis(JNIEnv *env,
                                                                                 jobject thiz,
                                                                                 jint quality)
 {
-    return ktxTexture2_CompressBasis(get_ktx2_texture(env, thiz), static_cast<uint32_t>(quality));
+    ktxTexture2 *texture = get_ktx2_texture(env, thiz);
+    if (texture == NULL) 
+    {
+      ThrowDestroyed(env);
+      return 0;
+    }
+    return ktxTexture2_CompressBasis(texture, static_cast<uint32_t>(quality));
 }
 
 extern "C" JNIEXPORT jint JNICALL Java_org_khronos_ktx_KtxTexture2_transcodeBasis(JNIEnv *env,
@@ -74,43 +146,45 @@ extern "C" JNIEXPORT jint JNICALL Java_org_khronos_ktx_KtxTexture2_transcodeBasi
                                                                                 jint outputFormat,
                                                                                 jint transcodeFlags)
 {
+    ktxTexture2 *texture = get_ktx2_texture(env, thiz);
+    if (texture == NULL) 
+    {
+      ThrowDestroyed(env);
+      return 0;
+    }
     return ktxTexture2_TranscodeBasis(
-        get_ktx2_texture(env, thiz),
+        texture,
         static_cast<ktx_transcode_fmt_e>(outputFormat),
         transcodeFlags);
 }
 
 extern "C" JNIEXPORT jobject JNICALL Java_org_khronos_ktx_KtxTexture2_create(JNIEnv *env,
              jobject,
-
              jobject jcreateInfo,
-
              jint jStorageAllocation)
 {
+    if (jcreateInfo == NULL) 
+    {
+      ThrowByName(env, "java/lang/NullPointerException", "Parameter 'jcreateInfo' is null for create");
+      return NULL;
+    }
+
     ktxTextureCreateInfo info;
     copy_ktx_texture_create_info(env, jcreateInfo, info);
     ktxTextureCreateStorageEnum storageAllocation = static_cast<ktxTextureCreateStorageEnum>(jStorageAllocation);
 
     ktxTexture2 *instance;
-    KTX_error_code result;
-
-    result = ktxTexture2_Create(&info, storageAllocation, &instance);
+    KTX_error_code result = ktxTexture2_Create(&info, storageAllocation, &instance);
 
     if (result != KTX_SUCCESS)
     {
-        std::cout << "Failure to create Ktx2Texture, error " << result << std::endl;
+        ThrowByName(env, "org/khronos/ktx/KtxException", ktxErrorString(result));
         return NULL;
     }
 
     assert (instance != NULL);
 
-    jclass ktx_texture_class = env->FindClass("org/khronos/ktx/KtxTexture2");
-    assert (ktx_texture_class != NULL);
-
-    jmethodID ktx_texture_ctor = env->GetMethodID(ktx_texture_class, "<init>", "(J)V");
-    jobject texture = env->NewObject(ktx_texture_class, ktx_texture_ctor, reinterpret_cast<jlong>(instance));
-
-    return texture;
+    return make_ktx2_wrapper(env, instance);
 }
 
 extern "C" JNIEXPORT jobject JNICALL Java_org_khronos_ktx_KtxTexture2_createFromNamedFile(JNIEnv *env,
@@ -118,13 +192,24 @@ extern "C" JNIEXPORT jobject JNICALL Java_org_khronos_ktx_KtxTexture2_createFrom
                                                                                             jstring filename,
                                                                                             jint createFlags)
 {
+    if (filename == NULL) 
+    {
+      ThrowByName(env, "java/lang/NullPointerException", "Parameter 'filename' is null for createFromNamedFile");
+      return NULL;
+    }
+
     const char *filenameArray = env->GetStringUTFChars(filename, NULL);
+    if (filenameArray == NULL) 
+    {
+      // OutOfMemoryError is already pending
+      return NULL;
+    }
     ktxTexture2 *instance = NULL;
 
-    jint result = ktxTexture2_CreateFromNamedFile(filenameArray, createFlags, &instance);
+    KTX_error_code result = ktxTexture2_CreateFromNamedFile(filenameArray, createFlags, &instance);
 
     if (result != KTX_SUCCESS) {
-        std::cout << "Failure to createFromNamedFile Ktx2Texture, error " << result << std::endl;
+        ThrowByName(env, "org/khronos/ktx/KtxException", ktxErrorString(result));
         return NULL;
     }
 
@@ -133,16 +218,65 @@ extern "C" JNIEXPORT jobject JNICALL Java_org_khronos_ktx_KtxTexture2_createFrom
     return make_ktx2_wrapper(env, instance);
 }
 
+extern "C" JNIEXPORT jobject JNICALL Java_org_khronos_ktx_KtxTexture2_createFromMemory(JNIEnv *env,
+                                                                                       jclass, 
+                                                                                       jobject byteBuffer,
+                                                                                       jint createFlags)
+{
+    if (byteBuffer == NULL) 
+    {
+      ThrowByName(env, "java/lang/NullPointerException", "Parameter 'byteBuffer' is null for createFromMemory");
+      return NULL;
+    }
+
+    jbyte *baseAddress = NULL;
+    jbyte *actualAddress = NULL;
+    jint length = 0;
+    bool acquired = getBufferData(env, byteBuffer, &baseAddress, &actualAddress, &length);
+    if (!acquired) {
+        ThrowByName(env, "org/khronos/ktx/KtxException", "Could not obtain data from input buffer");
+        return NULL;
+    }
+    ktxTexture2 *instance = NULL;
+    ktx_uint8_t *inputData = reinterpret_cast<ktx_uint8_t*>(actualAddress);
+    ktx_size_t size = static_cast<ktx_size_t>(length);
+
+    KTX_error_code result = ktxTexture2_CreateFromMemory(inputData, size, createFlags, &instance);
+    releaseBufferData(env, byteBuffer, baseAddress);
+    if (env->ExceptionCheck()) {
+      return NULL;
+    }
+    if (result != KTX_SUCCESS) {
+        ThrowByName(env, "org/khronos/ktx/KtxException", ktxErrorString(result));
+        return NULL;
+    }
+    assert (instance != NULL);
+    return make_ktx2_wrapper(env, instance);
+}
+
+
 extern "C" JNIEXPORT jint JNICALL Java_org_khronos_ktx_KtxTexture2_deflateZstd(JNIEnv *env,
                                                                                jobject thiz,
                                                                                jint level)
 {
-  return ktxTexture2_DeflateZstd(get_ktx2_texture(env, thiz), static_cast<ktx_uint32_t>(level));
+    ktxTexture2 *texture = get_ktx2_texture(env, thiz);
+    if (texture == NULL) 
+    {
+      ThrowDestroyed(env);
+      return 0;
+    }
+    return ktxTexture2_DeflateZstd(texture, static_cast<ktx_uint32_t>(level));
 }
 
 extern "C" JNIEXPORT jint JNICALL Java_org_khronos_ktx_KtxTexture2_deflateZLIB(JNIEnv *env,
                                                                                jobject thiz,
                                                                                jint level)
 {
-  return ktxTexture2_DeflateZLIB(get_ktx2_texture(env, thiz), static_cast<ktx_uint32_t>(level));
+    ktxTexture2 *texture = get_ktx2_texture(env, thiz);
+    if (texture == NULL) 
+    {
+      ThrowDestroyed(env);
+      return 0;
+    }
+    return ktxTexture2_DeflateZLIB(texture, static_cast<ktx_uint32_t>(level));
 }
diff --git a/interface/java_binding/src/main/cpp/libktx-jni.cpp b/interface/java_binding/src/main/cpp/libktx-jni.cpp
index 150be38fca..9e32607bf2 100644
--- a/interface/java_binding/src/main/cpp/libktx-jni.cpp
+++ b/interface/java_binding/src/main/cpp/libktx-jni.cpp
@@ -1,5 +1,6 @@
 /*
  * Copyright (c) 2021, Shukant Pal and Contributors
+ * Copyright (c) 2024, Khronos Group and Contributors
  * SPDX-License-Identifier: Apache-2.0
  */
 
@@ -8,165 +9,413 @@
 
 #include <iostream>
 
-ktxTexture *get_ktx_texture(JNIEnv *env, jobject thiz)
+// The global references to the required Java classes
+jclass KtxTexture1_class;
+jclass KtxTexture2_class;
+jclass Buffer_class;
+
+// The method IDs for the constructors of the KTX Java classes
+jmethodID KtxTexture1_constructor;
+jmethodID KtxTexture2_constructor;
+
+// The method IDs for the Java classes
+// The comment indicates their signature/type
+jmethodID Buffer_position_method; // "()I"
+jmethodID Buffer_limit_method; // "()I"
+jmethodID Buffer_isDirect_method; // "()Z"
+jmethodID Buffer_hasArray_method; // "()Z"
+jmethodID Buffer_array_method; // "()Ljava/lang/Object;"
+
+// The field IDs of the Java classes 
+// The comment indicates their signature/type
+
+jfieldID KtxTexture_instance_field; // "J"
+
+jfieldID KtxTextureCreateInfo_glInternalformat_field; // "I"
+jfieldID KtxTextureCreateInfo_baseWidth_field; ; // "I"
+jfieldID KtxTextureCreateInfo_baseHeight_field; // "I"
+jfieldID KtxTextureCreateInfo_baseDepth_field; // "I"
+jfieldID KtxTextureCreateInfo_numDimensions_field; // "I"
+jfieldID KtxTextureCreateInfo_numLevels_field; // "I"
+jfieldID KtxTextureCreateInfo_numLayers_field; // "I"
+jfieldID KtxTextureCreateInfo_numFaces_field; // "I"
+jfieldID KtxTextureCreateInfo_isArray_field; // "Z"
+jfieldID KtxTextureCreateInfo_generateMipmaps_field; // "Z"
+jfieldID KtxTextureCreateInfo_vkFormat_field; // "I"
+
+jfieldID KtxAstcParams_verbose_field; // "Z"
+jfieldID KtxAstcParams_threadCount_field; // "I"
+jfieldID KtxAstcParams_blockDimension_field; // "I"
+jfieldID KtxAstcParams_mode_field; // "I"
+jfieldID KtxAstcParams_qualityLevel_field; // "I"
+jfieldID KtxAstcParams_normalMap_field; // "Z"
+jfieldID KtxAstcParams_perceptual_field; // "Z"
+jfieldID KtxAstcParams_inputSwizzle_field; // "[C"
+
+jfieldID KtxBasisParams_uastc_field; // "Z"
+jfieldID KtxBasisParams_verbose_field; // "Z"
+jfieldID KtxBasisParams_noSSE_field; // "Z"
+jfieldID KtxBasisParams_threadCount_field; // "I"
+jfieldID KtxBasisParams_compressionLevel_field; // "I"
+jfieldID KtxBasisParams_qualityLevel_field; // "I"
+jfieldID KtxBasisParams_maxEndpoints_field; // "I"
+jfieldID KtxBasisParams_endpointRDOThreshold_field; // "F"
+jfieldID KtxBasisParams_maxSelectors_field; // "I"
+jfieldID KtxBasisParams_selectorRDOThreshold_field; // "F"
+jfieldID KtxBasisParams_inputSwizzle_field; // "[C"
+jfieldID KtxBasisParams_normalMap_field; // "Z"
+jfieldID KtxBasisParams_preSwizzle_field; // "Z"
+jfieldID KtxBasisParams_noEndpointRDO_field; // "Z"
+jfieldID KtxBasisParams_noSelectorRDO_field; // "Z"
+jfieldID KtxBasisParams_uastcFlags_field; // "I"
+jfieldID KtxBasisParams_uastcRDO_field; // "Z"
+jfieldID KtxBasisParams_uastcRDOQualityScalar_field; // "F"
+jfieldID KtxBasisParams_uastcRDODictSize_field; // "I"
+jfieldID KtxBasisParams_uastcRDOMaxSmoothBlockErrorScale_field; // "F"
+jfieldID KtxBasisParams_uastcRDOMaxSmoothBlockStdDev_field; // "F"
+jfieldID KtxBasisParams_uastcRDODontFavorSimplerModes_field; // "Z"
+jfieldID KtxBasisParams_uastcRDONoMultithreading_field; // "Z"
+
+
+/**
+ * Called when the library is loaded. 
+ * 
+ * This will initialize all required classes, field IDs, and method IDs
+ */
+JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM *jvm, void *)
 {
-    jclass ktx_texture_class = env->GetObjectClass(thiz);
-    jfieldID ktx_instance_field = env->GetFieldID(ktx_texture_class, "instance", "J");
+    JNIEnv *env = NULL;
+    if (jvm->GetEnv((void **)&env, JNI_VERSION_1_4))
+    {
+        return JNI_ERR;
+    }
+
+    jclass cls = NULL;
+
+    // Obtain the KtxTexture1 class and its constructor
+    if (!initClass(env, cls, "org/khronos/ktx/KtxTexture1")) return JNI_ERR;
+    if (!initMethod(env, cls, KtxTexture1_constructor, "<init>", "(J)V")) return JNI_ERR;
+    KtxTexture1_class = (jclass)env->NewGlobalRef(cls);
+    if (KtxTexture1_class == NULL)
+    {
+        std::cerr << "Failed to create reference to KtxTexture1 class " << std::endl;
+        return JNI_ERR;
+    }
+
+    // Obtain the KtxTexture2 class and its constructor
+    if (!initClass(env, cls, "org/khronos/ktx/KtxTexture2")) return JNI_ERR;
+    if (!initMethod(env, cls, KtxTexture2_constructor, "<init>", "(J)V")) return JNI_ERR;
+    KtxTexture2_class = (jclass)env->NewGlobalRef(cls);
+    if (KtxTexture1_class == NULL)
+    {
+        std::cerr << "Failed to create reference to KtxTexture2 class " << std::endl;
+        return JNI_ERR;
+    }
 
-    return reinterpret_cast<ktxTexture*>(env->GetLongField(thiz, ktx_instance_field));
+    // Obtain the method IDs for the Buffer class
+    if (!initClass(env, cls, "java/nio/Buffer")) return JNI_ERR;
+    if (!initMethod(env, cls, Buffer_position_method, "position", "()I")) return JNI_ERR;
+    if (!initMethod(env, cls, Buffer_limit_method, "limit", "()I")) return JNI_ERR;
+    if (!initMethod(env, cls, Buffer_isDirect_method, "isDirect", "()Z")) return JNI_ERR;
+    if (!initMethod(env, cls, Buffer_hasArray_method, "hasArray", "()Z")) return JNI_ERR;
+    if (!initMethod(env, cls, Buffer_array_method, "array", "()Ljava/lang/Object;")) return JNI_ERR;
+
+    // Obtain the fieldIDs of the KtxTexture class
+    if (!initClass(env, cls, "org/khronos/ktx/KtxTexture")) return JNI_ERR;
+    if (!initField(env, cls, KtxTexture_instance_field, "instance", "J")) return JNI_ERR;
+
+    // Obtain the fieldIDs of the KtxTextureCreateInfo class
+    if (!initClass(env, cls, "org/khronos/ktx/KtxTextureCreateInfo")) return JNI_ERR;
+    if (!initField(env, cls, KtxTextureCreateInfo_glInternalformat_field, "glInternalformat", "I")) return JNI_ERR;
+    if (!initField(env, cls, KtxTextureCreateInfo_baseWidth_field, "baseWidth", "I")) return JNI_ERR;
+    if (!initField(env, cls, KtxTextureCreateInfo_baseHeight_field, "baseHeight", "I")) return JNI_ERR;
+    if (!initField(env, cls, KtxTextureCreateInfo_baseDepth_field, "baseDepth", "I")) return JNI_ERR;
+    if (!initField(env, cls, KtxTextureCreateInfo_numDimensions_field, "numDimensions", "I")) return JNI_ERR;
+    if (!initField(env, cls, KtxTextureCreateInfo_numLevels_field, "numLevels", "I")) return JNI_ERR;
+    if (!initField(env, cls, KtxTextureCreateInfo_numLayers_field, "numLayers", "I")) return JNI_ERR;
+    if (!initField(env, cls, KtxTextureCreateInfo_numFaces_field, "numFaces", "I")) return JNI_ERR;
+    if (!initField(env, cls, KtxTextureCreateInfo_isArray_field, "isArray", "Z")) return JNI_ERR;
+    if (!initField(env, cls, KtxTextureCreateInfo_generateMipmaps_field, "generateMipmaps", "Z")) return JNI_ERR;
+    if (!initField(env, cls, KtxTextureCreateInfo_vkFormat_field, "vkFormat", "I")) return JNI_ERR;
+
+    // Obtain the fieldIDs of the KtxAstcParams class
+    if (!initClass(env, cls, "org/khronos/ktx/KtxAstcParams")) return JNI_ERR;
+    if (!initField(env, cls, KtxAstcParams_verbose_field, "verbose", "Z")) return JNI_ERR;
+    if (!initField(env, cls, KtxAstcParams_threadCount_field, "threadCount", "I")) return JNI_ERR;
+    if (!initField(env, cls, KtxAstcParams_blockDimension_field, "blockDimension", "I")) return JNI_ERR;
+    if (!initField(env, cls, KtxAstcParams_mode_field, "mode", "I")) return JNI_ERR;
+    if (!initField(env, cls, KtxAstcParams_qualityLevel_field, "qualityLevel", "I")) return JNI_ERR;
+    if (!initField(env, cls, KtxAstcParams_normalMap_field, "normalMap", "Z")) return JNI_ERR;
+    if (!initField(env, cls, KtxAstcParams_perceptual_field, "perceptual", "Z")) return JNI_ERR;
+    if (!initField(env, cls, KtxAstcParams_inputSwizzle_field, "inputSwizzle", "[C")) return JNI_ERR;
+
+    // Obtain the fieldIDs of the KtxBasisParams class
+    if (!initClass(env, cls, "org/khronos/ktx/KtxBasisParams")) return JNI_ERR;
+    if (!initField(env, cls, KtxBasisParams_uastc_field, "uastc", "Z")) return JNI_ERR;
+    if (!initField(env, cls, KtxBasisParams_verbose_field, "verbose", "Z")) return JNI_ERR;
+    if (!initField(env, cls, KtxBasisParams_noSSE_field, "noSSE", "Z")) return JNI_ERR;
+    if (!initField(env, cls, KtxBasisParams_threadCount_field, "threadCount", "I")) return JNI_ERR;
+    if (!initField(env, cls, KtxBasisParams_compressionLevel_field, "compressionLevel", "I")) return JNI_ERR;
+    if (!initField(env, cls, KtxBasisParams_qualityLevel_field, "qualityLevel", "I")) return JNI_ERR;
+    if (!initField(env, cls, KtxBasisParams_maxEndpoints_field, "maxEndpoints", "I")) return JNI_ERR;
+    if (!initField(env, cls, KtxBasisParams_endpointRDOThreshold_field, "endpointRDOThreshold", "F")) return JNI_ERR;
+    if (!initField(env, cls, KtxBasisParams_maxSelectors_field, "maxSelectors", "I")) return JNI_ERR;
+    if (!initField(env, cls, KtxBasisParams_selectorRDOThreshold_field, "selectorRDOThreshold", "F")) return JNI_ERR;
+    if (!initField(env, cls, KtxBasisParams_inputSwizzle_field, "inputSwizzle", "[C")) return JNI_ERR;
+    if (!initField(env, cls, KtxBasisParams_normalMap_field, "normalMap", "Z")) return JNI_ERR;
+    if (!initField(env, cls, KtxBasisParams_preSwizzle_field, "preSwizzle", "Z")) return JNI_ERR;
+    if (!initField(env, cls, KtxBasisParams_noEndpointRDO_field, "noEndpointRDO", "Z")) return JNI_ERR;
+    if (!initField(env, cls, KtxBasisParams_noSelectorRDO_field, "noSelectorRDO", "Z")) return JNI_ERR;
+    if (!initField(env, cls, KtxBasisParams_uastcFlags_field, "uastcFlags", "I")) return JNI_ERR;
+    if (!initField(env, cls, KtxBasisParams_uastcRDO_field, "uastcRDO", "Z")) return JNI_ERR;
+    if (!initField(env, cls, KtxBasisParams_uastcRDOQualityScalar_field, "uastcRDOQualityScalar", "F")) return JNI_ERR;
+    if (!initField(env, cls, KtxBasisParams_uastcRDODictSize_field, "uastcRDODictSize", "I")) return JNI_ERR;
+    if (!initField(env, cls, KtxBasisParams_uastcRDOMaxSmoothBlockErrorScale_field, "uastcRDOMaxSmoothBlockErrorScale", "F")) return JNI_ERR;
+    if (!initField(env, cls, KtxBasisParams_uastcRDOMaxSmoothBlockStdDev_field, "uastcRDOMaxSmoothBlockStdDev", "F")) return JNI_ERR;
+    if (!initField(env, cls, KtxBasisParams_uastcRDODontFavorSimplerModes_field, "uastcRDODontFavorSimplerModes", "Z")) return JNI_ERR;
+    if (!initField(env, cls, KtxBasisParams_uastcRDONoMultithreading_field, "uastcRDONoMultithreading", "Z")) return JNI_ERR;
+
+     return JNI_VERSION_1_4;
 }
 
-void set_ktx_texture(JNIEnv *env, jobject thiz, ktxTexture *texture)
+bool initClass(JNIEnv *env, jclass& cls, const char *name)
 {
-    jclass ktx_texture_class = env->GetObjectClass(thiz);
-    jfieldID ktx_instance_field = env->GetFieldID(ktx_texture_class, "instance", "J");
+    cls = env->FindClass(name);
+    if (cls == NULL)
+    {
+        std::cerr << "Failed to initialize class " << name << std::endl;
+        return false;
+    }
+    return true;
+}
 
-    env->SetLongField(thiz,
-                        ktx_instance_field,
-                        reinterpret_cast<jlong>(texture));
+bool initField(JNIEnv *env, jclass cls, jfieldID& field, const char *name, const char *signature)
+{
+    field = env->GetFieldID(cls, name, signature);
+    if (field == NULL)
+    {
+        std::cerr << "Failed to initialize field " << name << std::endl;
+        return false;
+    }
+    return true;
 }
 
-jobject make_ktx1_wrapper(JNIEnv *env, ktxTexture1 *texture)
+bool initMethod(JNIEnv *env, jclass cls, jmethodID& method, const char *name, const char *signature)
 {
-    jclass ktx_texture_class = env->FindClass("org/khronos/ktx/KtxTexture1");
-    assert (ktx_texture_class != NULL);
+    method = env->GetMethodID(cls, name, signature);
+    if (method == NULL)
+    {
+        std::cerr << "Failed to initialize method " << name << std::endl;
+        return false;
+    }
+    return true;
+}
 
-    jmethodID ktx_texture_ctor = env->GetMethodID(ktx_texture_class, "<init>", "(J)V");
 
-    return env->NewObject(ktx_texture_class, ktx_texture_ctor, reinterpret_cast<jlong>(texture));
+ktxTexture *get_ktx_texture(JNIEnv *env, jobject thiz)
+{
+    return reinterpret_cast<ktxTexture*>(env->GetLongField(thiz, KtxTexture_instance_field));
 }
 
-jobject make_ktx2_wrapper(JNIEnv *env, ktxTexture2 *texture)
+void set_ktx_texture(JNIEnv *env, jobject thiz, ktxTexture *texture)
 {
-    jclass ktx_texture_class = env->FindClass("org/khronos/ktx/KtxTexture2");
-    assert (ktx_texture_class != NULL);
+    env->SetLongField(thiz,
+                        KtxTexture_instance_field,
+                        reinterpret_cast<jlong>(texture));
+}
 
-    jmethodID ktx_texture_ctor = env->GetMethodID(ktx_texture_class, "<init>", "(J)V");
+jobject make_ktx1_wrapper(JNIEnv *env, ktxTexture1 *texture)
+{
+    return env->NewObject(KtxTexture1_class, KtxTexture1_constructor, reinterpret_cast<jlong>(texture));
+}
 
-    return env->NewObject(ktx_texture_class, ktx_texture_ctor, reinterpret_cast<jlong>(texture));
+jobject make_ktx2_wrapper(JNIEnv *env, ktxTexture2 *texture)
+{
+    return env->NewObject(KtxTexture2_class, KtxTexture2_constructor, reinterpret_cast<jlong>(texture));
 }
 
 void copy_ktx_texture_create_info(JNIEnv *env, jobject info, ktxTextureCreateInfo &out)
 {
-    jclass ktx_info_class = env->GetObjectClass(info);
-    jfieldID f_gl_internalformat = env->GetFieldID(ktx_info_class, "glInternalformat", "I");
-    jfieldID f_base_width = env->GetFieldID(ktx_info_class, "baseWidth", "I");
-    jfieldID f_base_height = env->GetFieldID(ktx_info_class, "baseHeight", "I");
-    jfieldID f_base_depth = env->GetFieldID(ktx_info_class, "baseDepth", "I");
-    jfieldID f_num_dimensions = env->GetFieldID(ktx_info_class, "numDimensions", "I");
-    jfieldID f_num_levels = env->GetFieldID(ktx_info_class, "numLevels", "I");
-    jfieldID f_num_layers = env->GetFieldID(ktx_info_class, "numLayers", "I");
-    jfieldID f_num_faces = env->GetFieldID(ktx_info_class, "numFaces", "I");
-    jfieldID f_is_array = env->GetFieldID(ktx_info_class, "isArray", "Z");
-    jfieldID f_generate_mipmaps = env->GetFieldID(ktx_info_class, "generateMipmaps", "Z");
-    jfieldID f_vk_format = env->GetFieldID(ktx_info_class, "vkFormat", "I");
-
-    out.glInternalformat = env->GetIntField(info, f_gl_internalformat);
-    out.baseWidth = env->GetIntField(info, f_base_width);
-    out.baseHeight = env->GetIntField(info, f_base_height);
-    out.baseDepth = env->GetIntField(info, f_base_depth);
-    out.numDimensions = env->GetIntField(info, f_num_dimensions);
-    out.numLevels = env->GetIntField(info, f_num_levels);
-    out.numLayers = env->GetIntField(info, f_num_layers);
-    out.numFaces = env->GetIntField(info, f_num_faces);
-    out.isArray = env->GetBooleanField(info, f_is_array) ? KTX_TRUE : KTX_FALSE;
-    out.generateMipmaps = env->GetBooleanField(info, f_generate_mipmaps) ? KTX_TRUE : KTX_FALSE;
-    out.vkFormat = env->GetIntField(info, f_vk_format);
+    out.glInternalformat = env->GetIntField(info, KtxTextureCreateInfo_glInternalformat_field);
+    out.baseWidth = env->GetIntField(info, KtxTextureCreateInfo_baseWidth_field);
+    out.baseHeight = env->GetIntField(info, KtxTextureCreateInfo_baseHeight_field);
+    out.baseDepth = env->GetIntField(info, KtxTextureCreateInfo_baseDepth_field);
+    out.numDimensions = env->GetIntField(info, KtxTextureCreateInfo_numDimensions_field);
+    out.numLevels = env->GetIntField(info, KtxTextureCreateInfo_numLevels_field);
+    out.numLayers = env->GetIntField(info, KtxTextureCreateInfo_numLayers_field);
+    out.numFaces = env->GetIntField(info, KtxTextureCreateInfo_numFaces_field);
+    out.isArray = env->GetBooleanField(info, KtxTextureCreateInfo_isArray_field) ? KTX_TRUE : KTX_FALSE;
+    out.generateMipmaps = env->GetBooleanField(info, KtxTextureCreateInfo_generateMipmaps_field) ? KTX_TRUE : KTX_FALSE;
+    out.vkFormat = env->GetIntField(info, KtxTextureCreateInfo_vkFormat_field);
 }
 
-void copy_ktx_astc_params(JNIEnv *env, jobject params, ktxAstcParams &out)
+bool copy_ktx_astc_params(JNIEnv *env, jobject params, ktxAstcParams &out)
 {
     // Undocumented quirk!
     out.structSize = sizeof(ktxAstcParams);
 
-    jclass ktx_astc_params_class = env->GetObjectClass(params);
-    jfieldID verbose = env->GetFieldID(ktx_astc_params_class, "verbose", "Z");
-    jfieldID threadCount = env->GetFieldID(ktx_astc_params_class, "threadCount", "I");
-    jfieldID blockDimension = env->GetFieldID(ktx_astc_params_class, "blockDimension", "I");
-    jfieldID mode = env->GetFieldID(ktx_astc_params_class, "mode", "I");
-    jfieldID qualityLevel = env->GetFieldID(ktx_astc_params_class, "qualityLevel", "I");
-    jfieldID normalMap = env->GetFieldID(ktx_astc_params_class, "normalMap", "Z");
-    jfieldID perceptual = env->GetFieldID(ktx_astc_params_class, "perceptual", "Z");
-    jfieldID inputSwizzle = env->GetFieldID(ktx_astc_params_class, "inputSwizzle", "[C");
-
-    out.verbose = env->GetBooleanField(params, verbose);
-    out.threadCount = env->GetIntField(params, threadCount);
-    out.blockDimension = env->GetIntField(params, blockDimension);
-    out.mode = env->GetIntField(params, mode);
-    out.qualityLevel = env->GetIntField(params, qualityLevel);
-    out.normalMap = env->GetBooleanField(params, normalMap);
-    out.perceptual = env->GetBooleanField(params, perceptual);
-
-    jobject inputSwizzleObject = env->GetObjectField(params, inputSwizzle);
+    out.verbose = env->GetBooleanField(params, KtxAstcParams_verbose_field);
+    out.threadCount = env->GetIntField(params, KtxAstcParams_threadCount_field);
+    out.blockDimension = env->GetIntField(params, KtxAstcParams_blockDimension_field);
+    out.mode = env->GetIntField(params, KtxAstcParams_mode_field);
+    out.qualityLevel = env->GetIntField(params, KtxAstcParams_qualityLevel_field);
+    out.normalMap = env->GetBooleanField(params, KtxAstcParams_normalMap_field);
+    out.perceptual = env->GetBooleanField(params, KtxAstcParams_perceptual_field);
+
+    jobject inputSwizzleObject = env->GetObjectField(params, KtxAstcParams_inputSwizzle_field);
     jcharArray inputSwizzleArray = static_cast<jcharArray>(inputSwizzleObject);
     jchar *inputSwizzleValues = env->GetCharArrayElements( inputSwizzleArray, NULL);
+    if (inputSwizzleValues == NULL) 
+    {
+        // OutOfMemoryError is already pending
+        return false;
+    }
     for (int i=0; i<4; i++)
     {
       out.inputSwizzle[i] = static_cast<char>(inputSwizzleValues[i]);
     }
     env->ReleaseCharArrayElements(inputSwizzleArray, inputSwizzleValues, JNI_ABORT);
+    return true;
 }
 
-void copy_ktx_basis_params(JNIEnv *env, jobject params, ktxBasisParams &out)
+bool copy_ktx_basis_params(JNIEnv *env, jobject params, ktxBasisParams &out)
 {
     // Undocumented quirk!
     out.structSize = sizeof(ktxBasisParams);
 
-    jclass ktx_basis_params_class = env->GetObjectClass(params);
-    jfieldID uastc = env->GetFieldID(ktx_basis_params_class, "uastc", "Z");
-    jfieldID verbose = env->GetFieldID(ktx_basis_params_class, "verbose", "Z");
-    jfieldID noSSE = env->GetFieldID(ktx_basis_params_class, "noSSE", "Z");
-    jfieldID threadCount = env->GetFieldID(ktx_basis_params_class, "threadCount", "I");
-    jfieldID compressionLevel = env->GetFieldID(ktx_basis_params_class, "compressionLevel", "I");
-    jfieldID qualityLevel = env->GetFieldID(ktx_basis_params_class, "qualityLevel", "I");
-    jfieldID maxEndpoints = env->GetFieldID(ktx_basis_params_class, "maxEndpoints", "I");
-    jfieldID endpointRDOThreshold = env->GetFieldID(ktx_basis_params_class, "endpointRDOThreshold", "F");
-    jfieldID maxSelectors = env->GetFieldID(ktx_basis_params_class, "maxSelectors", "I");
-    jfieldID selectorRDOThreshold = env->GetFieldID(ktx_basis_params_class, "selectorRDOThreshold", "F");
-    jfieldID inputSwizzle = env->GetFieldID(ktx_basis_params_class, "inputSwizzle", "[C");
-    jfieldID normalMap = env->GetFieldID(ktx_basis_params_class, "normalMap", "Z");
-    jfieldID preSwizzle = env->GetFieldID(ktx_basis_params_class, "preSwizzle", "Z");
-    jfieldID noEndpointRDO = env->GetFieldID(ktx_basis_params_class, "noEndpointRDO", "Z");
-    jfieldID noSelectorRDO = env->GetFieldID(ktx_basis_params_class, "noSelectorRDO", "Z");
-    jfieldID uastcFlags = env->GetFieldID(ktx_basis_params_class, "uastcFlags", "I");
-    jfieldID uastcRDO = env->GetFieldID(ktx_basis_params_class, "uastcRDO", "Z");
-    jfieldID uastcRDOQualityScalar = env->GetFieldID(ktx_basis_params_class, "uastcRDOQualityScalar", "F");
-    jfieldID uastcRDODictSize = env->GetFieldID(ktx_basis_params_class, "uastcRDODictSize", "I");
-    jfieldID uastcRDOMaxSmoothBlockErrorScale = env->GetFieldID(ktx_basis_params_class, "uastcRDOMaxSmoothBlockErrorScale", "F");
-    jfieldID uastcRDOMaxSmoothBlockStdDev = env->GetFieldID(ktx_basis_params_class, "uastcRDOMaxSmoothBlockStdDev", "F");
-    jfieldID uastcRDODontFavorSimplerModes = env->GetFieldID(ktx_basis_params_class, "uastcRDODontFavorSimplerModes", "Z");
-    jfieldID uastcRDONoMultithreading = env->GetFieldID(ktx_basis_params_class, "uastcRDONoMultithreading", "Z");
-
-    out.uastc = env->GetBooleanField(params, uastc);
-    out.verbose = env->GetBooleanField(params, verbose);
-    out.noSSE = env->GetBooleanField(params, noSSE);
-    out.threadCount = env->GetIntField(params, threadCount);
-    out.compressionLevel = env->GetIntField(params, compressionLevel);
-    out.qualityLevel = env->GetIntField(params, qualityLevel);
-    out.maxEndpoints = env->GetIntField(params, maxEndpoints);
-    out.endpointRDOThreshold = env->GetFloatField(params, endpointRDOThreshold);
-    out.maxSelectors = env->GetIntField(params, maxSelectors);
-    out.selectorRDOThreshold = env->GetFloatField(params, selectorRDOThreshold);
-
-    jobject inputSwizzleObject = env->GetObjectField(params, inputSwizzle);
+    out.uastc = env->GetBooleanField(params, KtxBasisParams_uastc_field);
+    out.verbose = env->GetBooleanField(params, KtxBasisParams_verbose_field);
+    out.noSSE = env->GetBooleanField(params, KtxBasisParams_noSSE_field);
+    out.threadCount = env->GetIntField(params, KtxBasisParams_threadCount_field);
+    out.compressionLevel = env->GetIntField(params, KtxBasisParams_compressionLevel_field);
+    out.qualityLevel = env->GetIntField(params, KtxBasisParams_qualityLevel_field);
+    out.maxEndpoints = env->GetIntField(params, KtxBasisParams_maxEndpoints_field);
+    out.endpointRDOThreshold = env->GetFloatField(params, KtxBasisParams_endpointRDOThreshold_field);
+    out.maxSelectors = env->GetIntField(params, KtxBasisParams_maxSelectors_field);
+    out.selectorRDOThreshold = env->GetFloatField(params, KtxBasisParams_selectorRDOThreshold_field);
+
+    jobject inputSwizzleObject = env->GetObjectField(params, KtxBasisParams_inputSwizzle_field);
     jcharArray inputSwizzleArray = static_cast<jcharArray>(inputSwizzleObject);
     jchar *inputSwizzleValues = env->GetCharArrayElements( inputSwizzleArray, NULL);
+    if (inputSwizzleValues == NULL) 
+    {
+        // OutOfMemoryError is already pending
+        return false;
+    }
     for (int i=0; i<4; i++)
     {
       out.inputSwizzle[i] = static_cast<char>(inputSwizzleValues[i]);
     }
     env->ReleaseCharArrayElements(inputSwizzleArray, inputSwizzleValues, JNI_ABORT);
 
-    out.normalMap = env->GetBooleanField(params, normalMap);
-    out.preSwizzle = env->GetBooleanField(params, preSwizzle);
-    out.noEndpointRDO = env->GetBooleanField(params, noEndpointRDO);
-    out.noSelectorRDO = env->GetBooleanField(params, noSelectorRDO);
-    out.uastcRDO = env->GetBooleanField(params, uastcRDO);
-    out.uastcFlags = env->GetIntField(params, uastcFlags);
-    out.uastcRDOQualityScalar = env->GetFloatField(params, uastcRDOQualityScalar);
-    out.uastcRDODictSize = env->GetIntField(params, uastcRDODictSize);
-    out.uastcRDOMaxSmoothBlockErrorScale = env->GetFloatField(params, uastcRDOMaxSmoothBlockErrorScale);
-    out.uastcRDOMaxSmoothBlockStdDev = env->GetFloatField(params, uastcRDOMaxSmoothBlockStdDev);
-    out.uastcRDODontFavorSimplerModes = env->GetBooleanField(params, uastcRDODontFavorSimplerModes);
-    out.uastcRDONoMultithreading = env->GetBooleanField(params, uastcRDONoMultithreading);
+    out.normalMap = env->GetBooleanField(params, KtxBasisParams_normalMap_field);
+    out.preSwizzle = env->GetBooleanField(params, KtxBasisParams_preSwizzle_field);
+    out.noEndpointRDO = env->GetBooleanField(params, KtxBasisParams_noEndpointRDO_field);
+    out.noSelectorRDO = env->GetBooleanField(params, KtxBasisParams_noSelectorRDO_field);
+    out.uastcRDO = env->GetBooleanField(params, KtxBasisParams_uastcRDO_field);
+    out.uastcFlags = env->GetIntField(params, KtxBasisParams_uastcFlags_field);
+    out.uastcRDOQualityScalar = env->GetFloatField(params, KtxBasisParams_uastcRDOQualityScalar_field);
+    out.uastcRDODictSize = env->GetIntField(params, KtxBasisParams_uastcRDODictSize_field);
+    out.uastcRDOMaxSmoothBlockErrorScale = env->GetFloatField(params, KtxBasisParams_uastcRDOMaxSmoothBlockErrorScale_field);
+    out.uastcRDOMaxSmoothBlockStdDev = env->GetFloatField(params, KtxBasisParams_uastcRDOMaxSmoothBlockStdDev_field);
+    out.uastcRDODontFavorSimplerModes = env->GetBooleanField(params, KtxBasisParams_uastcRDODontFavorSimplerModes_field);
+    out.uastcRDONoMultithreading = env->GetBooleanField(params, KtxBasisParams_uastcRDONoMultithreading_field);
+
+    return true;
+}
+
+bool getBufferData(JNIEnv *env, jobject buffer, jbyte** baseAddress, jbyte **actualAddress, jint *length) {
+
+  // Obtain the position and limit of the buffer
+  jint position = env->CallIntMethod(buffer, Buffer_position_method);
+  if (env->ExceptionCheck()) {
+    return false;
+  }
+  jint limit = env->CallIntMethod(buffer, Buffer_limit_method);
+  if (env->ExceptionCheck()) {
+    return false;
+  }
+
+  // If the buffer is direct, then compute the results from
+  // the direct buffer address
+  jboolean isDirect = env->CallBooleanMethod(buffer, Buffer_isDirect_method);
+  if (env->ExceptionCheck()) {
+    return false;
+  }
+  if (isDirect == JNI_TRUE) {
+    void* address = env->GetDirectBufferAddress(buffer);
+    if (env->ExceptionCheck()) {
+      return false;
+    }
+    jbyte* start = static_cast<jbyte*>(address);
+    *baseAddress = start;
+    *actualAddress = start + position;
+    *length = (limit - position);
+    return true;
+  }
+
+  // If the buffer is backed by an array, then compute the
+  // results from the array elements. (These have to be 
+  // released in the releaseBufferData call!)
+  jboolean hasArray = env->CallBooleanMethod(buffer, Buffer_hasArray_method);
+  if (env->ExceptionCheck()) {
+    return false;
+  }
+  if (hasArray == JNI_TRUE) {
+    jobject array = env->CallObjectMethod(buffer, Buffer_array_method);
+    if (env->ExceptionCheck()) {
+      return false;
+    }
+    jbyte* start = env->GetByteArrayElements(static_cast<jbyteArray>(array), NULL);
+    if (start == NULL) 
+    {
+      // OutOfMemoryError is already pending
+      return false;
+    }
+    *baseAddress = start;
+    *actualAddress = start + position;
+    *length = (limit - position);
+    return true;
+  }
+
+  return false;
+}
+
+void releaseBufferData(JNIEnv *env, jobject buffer, jbyte* baseAddress) {
+
+  // For direct buffers, nothing has to be done
+  jboolean isDirect = env->CallBooleanMethod(buffer, Buffer_isDirect_method);
+  if (env->ExceptionCheck()) {
+    return;
+  }
+  if (isDirect == JNI_FALSE) {
+    return;
+  }
+
+  // For array-backed buffers, the elements are released, without
+  // writing back any changes
+  jboolean hasArray = env->CallBooleanMethod(buffer, Buffer_hasArray_method);
+  if (env->ExceptionCheck()) {
+    return;
+  }
+  if (hasArray == JNI_TRUE) {
+    jobject array = env->CallObjectMethod(buffer, Buffer_array_method);
+    env->ReleaseByteArrayElements(static_cast<jbyteArray>(array), baseAddress, JNI_ABORT);
+  }
+}
+
+void ThrowByName(JNIEnv *env, const char *name, const char *msg)
+{
+    jclass cls = env->FindClass(name);
+    if (cls != NULL)
+    {
+        env->ThrowNew(cls, msg);
+    }
+    env->DeleteLocalRef(cls);
 }
+
+void ThrowDestroyed(JNIEnv *env) 
+{
+    ThrowByName(env, "java/lang/IllegalStateException", "Cannot use a texture after destroy() was called");
+}
+
diff --git a/interface/java_binding/src/main/cpp/libktx-jni.h b/interface/java_binding/src/main/cpp/libktx-jni.h
index 7fb0c4751c..3f38ebc110 100644
--- a/interface/java_binding/src/main/cpp/libktx-jni.h
+++ b/interface/java_binding/src/main/cpp/libktx-jni.h
@@ -1,5 +1,6 @@
 /*
  * Copyright (c) 2021, Shukant Pal and Contributors
+ * Copyright (c) 2024, Khronos Group and Contributors
  * SPDX-License-Identifier: Apache-2.0
  */
 
@@ -17,8 +18,8 @@ jobject make_ktx1_wrapper(JNIEnv *env, ktxTexture1 *texture);
 jobject make_ktx2_wrapper(JNIEnv *env, ktxTexture2 *texture);
 
 void copy_ktx_texture_create_info(JNIEnv *env, jobject info, ktxTextureCreateInfo &out);
-void copy_ktx_astc_params(JNIEnv *env, jobject params, ktxAstcParams &out);
-void copy_ktx_basis_params(JNIEnv *env, jobject params, ktxBasisParams &out);
+bool copy_ktx_astc_params(JNIEnv *env, jobject params, ktxAstcParams &out);
+bool copy_ktx_basis_params(JNIEnv *env, jobject params, ktxBasisParams &out);
 
 static inline ktxTexture1 *get_ktx1_texture(JNIEnv *env, jobject thiz)
 {
@@ -30,4 +31,103 @@ static inline ktxTexture2 *get_ktx2_texture(JNIEnv *env, jobject thiz)
     return reinterpret_cast<ktxTexture2*>(get_ktx_texture(env, thiz));
 }
 
+/**
+ * Initialize the given jclass, and return whether
+ * the initialization succeeded
+ * 
+ * @param env The JNI environment pointer
+ * @param cls The class
+ * @param name The name of the class, e.g. "java/lang/Object"
+ * @return Whether the initialization succeeded
+ */
+bool initClass(JNIEnv *env, jclass& cls, const char *name);
+
+/**
+ * Initialize the specified field ID, and return whether
+ * the initialization succeeded
+ * 
+ * @param env The JNI environment pointer
+ * @param field The field ID
+ * @param name The name of the field
+ * @param signature The signature of the field, 
+ * "I" for int, "J" for long, or a class like "Ljava.nio.Buffer;"
+ * @return Whether the initialization succeeded
+ */
+bool initField(JNIEnv *env, jclass cls, jfieldID& field, const char *name, const char *signature);
+
+/**
+ * Initialize the specified method ID, and return whether
+ * the initialization succeeded
+ * 
+ * @param env The JNI environment pointer
+ * @param method The method ID
+ * @param name The name of the method
+ * @param signature The signature of the method
+ * @return Whether the initialization succeeded
+ */
+bool initMethod(JNIEnv *env, jclass cls, jmethodID& method, const char *name, const char *signature);
+
+/**
+ * Obtain the data of the given ByteBuffer.
+ * 
+ * The data may not be modified by callers!
+ * 
+ * This will take into account the position and limit of the given buffer,
+ * and handle the case that the buffer is a direct- or an array-based 
+ * buffer, and fill the given parameters accordingly:
+ * 
+ * The baseAddress will be the direct buffer address, or the start of
+ * the array elements.
+ * 
+ * The actualAddress will be the base address, plus the 'position' of
+ * the given buffer.
+ * 
+ * The length will be the 'limit-position' of the given buffer.
+ * 
+ * The data can only be assumed to be valid until releaseBufferData is
+ * called, passing in the 'baseAddress' that was created by this function.
+ * 
+ * The returned data has to be considered to be read-only. Whether or
+ * not changes will affect the given buffer depends on whether the
+ * buffer is a direct- or an array-based buffer. The behavior when
+ * modifying the returned data is not specified.
+ * 
+ * @param env The JNI environment pointer
+ * @param buffer The buffer object
+ * @param baseAddress The pointer that will receive the base address
+ * @param actualAddress The pointer that will receive the actual address,
+ * which is 'baseAddress + position'
+ * @param length The pointer that will receive the length (which 
+ * is 'limit-position')
+ * @return Whether the buffer data could be obtained
+ */
+bool getBufferData(JNIEnv *env, jobject buffer, jbyte** baseAddress, jbyte **actualAddress, jint *length);
+
+/**
+ * Release the buffer data that was obtained with 'getBufferData'.
+ * 
+ * The given baseAddress has to be the address that was obtained from
+ * the 'getBufferData' call. For the case that the buffer is an 
+ * array-backed buffer, this function will NOT write back any
+ * changes that may have been made in the buffer data.
+ * 
+ * @param env The JNI environment pointer
+ * @param buffer The buffer object
+ * @param baseAddress The base address obtained with 'getBufferData'
+ */
+void releaseBufferData(JNIEnv *env, jobject buffer, jbyte* baseAddress);
+
+/**
+ * Throws a new Java Exception that is identified by the given name, e.g.
+ * "java/lang/IllegalArgumentException"
+ * and contains the given message.
+ */
+void ThrowByName(JNIEnv *env, const char *name, const char *msg);
+
+/**
+ * Throws a new Java Exception that indicates that a KTX texture
+ * was used after its 'destroy()' method was called
+ */
+void ThrowDestroyed(JNIEnv *env);
+
 #endif
diff --git a/interface/java_binding/src/main/java/org/khronos/ktx/KhrDfTransfer.java b/interface/java_binding/src/main/java/org/khronos/ktx/KhrDfTransfer.java
new file mode 100644
index 0000000000..ebd271676a
--- /dev/null
+++ b/interface/java_binding/src/main/java/org/khronos/ktx/KhrDfTransfer.java
@@ -0,0 +1,177 @@
+/*
+ * Copyright (c) 2024, Khronos Group and Contributors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+package org.khronos.ktx;
+
+/**
+ * Definition of the optical to digital transfer function ("gamma correction").<br>
+ * <br>
+ * Most transfer functions are not a pure power function and also include a
+ * linear element. LAB and related absolute color representations should use
+ * {@link #UNSPECIFIED}.<br>
+ * <br>
+ * These constants are returned by {@link KtxTexture2#getOETF()}.
+ */
+public class KhrDfTransfer {
+	/**
+	 * No transfer function defined
+	 */
+	public static final int UNSPECIFIED = 0;
+
+	/**
+	 * Linear transfer function (value proportional to intensity)
+	 */
+	public static final int LINEAR = 1;
+
+	/**
+	 * Perceptually-linear transfer function of sRGH (~2.4)
+	 */
+	public static final int SRGB = 2;
+
+	/**
+	 * Perceptually-linear transfer function of ITU BT.601, BT.709 and BT.2020
+	 * (~1/.45)
+	 */
+	public static final int ITU = 3;
+
+	/**
+	 * SMTPE170M (digital NTSC) defines an alias for the ITU transfer function
+	 * (~1/.45)
+	 */
+	public static final int SMTPE170M = 3;
+
+	/**
+	 * Perceptually-linear gamma function of original NTSC (simple 2.2 gamma)
+	 */
+	public static final int NTSC = 4;
+
+	/**
+	 * Sony S-log used by Sony video cameras
+	 */
+	public static final int SLOG = 5;
+
+	/**
+	 * Sony S-log 2 used by Sony video cameras
+	 */
+	public static final int SLOG2 = 6;
+
+	/**
+	 * ITU BT.1886 EOTF
+	 */
+	public static final int BT1886 = 7;
+
+	/**
+	 * ITU BT.2100 HLG OETF
+	 */
+	public static final int HLG_OETF = 8;
+
+	/**
+	 * ITU BT.2100 HLG EOTF
+	 */
+	public static final int HLG_EOTF = 9;
+
+	/**
+	 * ITU BT.2100 PQ EOTF
+	 */
+	public static final int PQ_EOTF = 10;
+
+	/**
+	 * ITU BT.2100 PQ OETF
+	 */
+	public static final int PQ_OETF = 11;
+
+	/**
+	 * DCI P3 transfer function
+	 */
+	public static final int DCIP3 = 12;
+
+	/**
+	 * Legacy PAL OETF
+	 */
+	public static final int PAL_OETF = 13;
+
+	/**
+	 * Legacy PAL 625-line EOTF
+	 */
+	public static final int PAL625_EOTF = 14;
+
+	/**
+	 * Legacy ST240 transfer function
+	 */
+	public static final int ST240 = 15;
+
+	/**
+	 * ACEScc transfer function
+	 */
+	public static final int ACESCC = 16;
+
+	/**
+	 * ACEScct transfer function
+	 */
+	public static final int ACESCCT = 17;
+
+	/**
+	 * Adobe RGB (1998) transfer function
+	 */
+	public static final int ADOBERGB = 18;
+
+	/**
+	 * Returns a string representation of the given transfer function
+	 *
+	 * @param n The transfer function
+	 * @return A string representation of the given transfer function
+	 */
+	public static String stringFor(int n) {
+		switch (n) {
+		case UNSPECIFIED:
+			return "UNSPECIFIED";
+		case LINEAR:
+			return "LINEAR";
+		case SRGB:
+			return "SRGB";
+		case SMTPE170M:
+			return "[ITU/SMTPE170M]";
+		case NTSC:
+			return "NTSC";
+		case SLOG:
+			return "SLOG";
+		case SLOG2:
+			return "SLOG2";
+		case BT1886:
+			return "BT1886";
+		case HLG_OETF:
+			return "HLG_OETF";
+		case HLG_EOTF:
+			return "HLG_EOTF";
+		case PQ_EOTF:
+			return "PQ_EOTF";
+		case PQ_OETF:
+			return "PQ_OETF";
+		case DCIP3:
+			return "DCIP3";
+		case PAL_OETF:
+			return "PAL_OETF";
+		case PAL625_EOTF:
+			return "PAL625_EOTF";
+		case ST240:
+			return "ST240";
+		case ACESCC:
+			return "ACESCC";
+		case ACESCCT:
+			return "ACESCCT";
+		case ADOBERGB:
+			return "ADOBERGB";
+		}
+		return "[Unknown KhrDfTransfer]";
+	}
+
+	/**
+	 * Private constructor to prevent instantiation
+	 */
+	private KhrDfTransfer() {
+		// Prevent instantiation
+	}
+
+
+}
diff --git a/interface/java_binding/src/main/java/org/khronos/ktx/KtxAstcParams.java b/interface/java_binding/src/main/java/org/khronos/ktx/KtxAstcParams.java
index 44b28daa69..f13564901f 100644
--- a/interface/java_binding/src/main/java/org/khronos/ktx/KtxAstcParams.java
+++ b/interface/java_binding/src/main/java/org/khronos/ktx/KtxAstcParams.java
@@ -1,85 +1,262 @@
 /*
+ * Copyright (c) 2024, Khronos Group and Contributors
  * Copyright (c) 2021, Shukant Pal and Contributors
  * SPDX-License-Identifier: Apache-2.0
  */
 
 package org.khronos.ktx;
 
+/**
+ * Structure for passing extended parameters to
+ * {@link KtxTexture2#compressAstcEx(KtxAstcParams)}.<br>
+ * <br>
+ * The default settings of an uninitialized structure will be:<br>
+ * <br>
+ * The <code>blockDimension</code> will be
+ * {@link KtxPackAstcBlockDimension#D4x4}<br>
+ * The <code>mode</code> will be
+ * {@link KtxPackAstcEncoderMode#LDR}<br>
+ * The <code>qualityLevel</code> will be
+ * {@link KtxPackAstcQualityLevel#FASTEST}<br>
+ * <br>
+ * Setting the <code>qualityLevel</code> to
+ * {@link KtxPackAstcQualityLevel#MEDIUM} is
+ * recommended.
+ */
 public class KtxAstcParams {
-    private boolean verbose;
-    private int threadCount;
-    private int blockDimension;
-    private int mode;
-    private int qualityLevel;
-    private boolean normalMap;
-    private boolean perceptual;
-    private char[] inputSwizzle = new char[4];
-
-    public boolean isVerbose() {
-        return verbose;
-    }
-
-    public void setVerbose(boolean verbose) {
-        this.verbose = verbose;
-    }
-
-    public int getThreadCount() {
-        return threadCount;
-    }
-
-    public void setThreadCount(int threadCount) {
-        this.threadCount = threadCount;
-    }
-
-    public int getBlockDimension() {
-        return blockDimension;
-    }
-
-    public void setBlockDimension(int blockDimension) {
-        this.blockDimension = blockDimension;
-    }
-
-    public int getMode() {
-        return mode;
-    }
-
-    public void setMode(int mode) {
-        this.mode = mode;
-    }
-
-    public int getQualityLevel() {
-        return qualityLevel;
-    }
-
-    public void setQualityLevel(int qualityLevel) {
-        this.qualityLevel = qualityLevel;
-    }
-
-    public boolean isNormalMap() {
-        return normalMap;
-    }
-
-    public void setNormalMap(boolean normalMap) {
-        this.normalMap = normalMap;
-    }
-
-    public boolean isPerceptual() {
-        return perceptual;
-    }
-
-    public void setPerceptual(boolean perceptual) {
-        this.perceptual = perceptual;
-    }
-
-    public char[] getInputSwizzle() {
-        return inputSwizzle;
-    }
-
-    public void setInputSwizzle(char[] inputSwizzle) {
-        if (inputSwizzle.length != 4) {
-            throw new IllegalArgumentException("inputSwizzle must be 4 bytes!");
-        }
-
-        this.inputSwizzle = inputSwizzle;
-    }
+
+	/**
+	 * If <code>true</code>, prints ASTC encoder operation details to the standard
+	 * output. Not recommended for GUI apps.
+	 */
+	private boolean verbose;
+
+	/**
+	 * Number of threads used for compression. Default is 1.
+	 */
+	private int threadCount;
+
+	/**
+	 * Combinations of block dimensions that astcenc supports, given as a
+	 * {@link KtxPackAstcBlockDimension} constant
+	 */
+	private int blockDimension;
+
+	/**
+	 * The {@link KtxPackAstcEncoderMode} constant
+	 */
+	private int mode;
+
+	/**
+	 * The quality level for the ASTC encoder
+	 */
+	private int qualityLevel;
+
+	/**
+	 * Whether to optimize for normal maps
+	 */
+	private boolean normalMap;
+
+	/**
+	 * Whether to optimize for perceptual error
+	 */
+	private boolean perceptual;
+
+	/**
+	 * The input swizzle to apply
+	 */
+	private char[] inputSwizzle = new char[4];
+
+	/**
+	 * Returns whether the ASTC encoder prints operation details to the standard
+	 * output
+	 *
+	 * @return The setting
+	 */
+	public boolean isVerbose() {
+		return verbose;
+	}
+
+	/**
+	 * If <code>true</code>, prints ASTC encoder operation details to the standard
+	 * output. Not recommended for GUI apps.
+	 *
+	 * @param verbose The setting
+	 */
+	public void setVerbose(boolean verbose) {
+		this.verbose = verbose;
+	}
+
+	/**
+	 * Returns the number of threads used for compression.
+	 *
+	 * @return The number of threads
+	 */
+	public int getThreadCount() {
+		return threadCount;
+	}
+
+	/**
+	 * Set the number of threads used for compression. Default is 1.
+	 *
+	 * @param threadCount The number of threads
+	 */
+	public void setThreadCount(int threadCount) {
+		this.threadCount = threadCount;
+	}
+
+	/**
+	 * Returns the current ASTC encoding block dimensions constant, as a value of
+	 * {@link KtxPackAstcBlockDimension}.
+	 *
+	 * @return The block dimension constant
+	 */
+	public int getBlockDimension() {
+		return blockDimension;
+	}
+
+	/**
+	 * Set the ASTC block dimension constant, as a value of
+	 * {@link KtxPackAstcBlockDimension}.
+	 *
+	 * @param blockDimension The block dimension constant
+	 */
+	public void setBlockDimension(int blockDimension) {
+		this.blockDimension = blockDimension;
+	}
+
+	/**
+	 * Returns the {@link KtxPackAstcEncoderMode} constant
+	 *
+	 * @return The encoder mode constant
+	 */
+	public int getMode() {
+		return mode;
+	}
+
+	/**
+	 * Set the {@link KtxPackAstcEncoderMode} constant
+	 *
+	 * @param mode The encoder mode constant
+	 */
+	public void setMode(int mode) {
+		this.mode = mode;
+	}
+
+	/**
+	 * Returns the {@link KtxPackAstcQualityLevel} constant
+	 *
+	 * @return The quality level constant
+	 */
+	public int getQualityLevel() {
+		return qualityLevel;
+	}
+
+	/**
+	 * Set the {@link KtxPackAstcQualityLevel} constant.<br>
+	 * <br>
+	 * Note that while this appears to be a simple integer value in the range [0,
+	 * 100], it does not seem to be guaranteed that all values are supposed. Only
+	 * the constants from the {@link KtxPackAstcQualityLevel} are guaranteed to be
+	 * supported.
+	 *
+	 * @param qualityLevel The quality level
+	 */
+	public void setQualityLevel(int qualityLevel) {
+		this.qualityLevel = qualityLevel;
+	}
+
+	/**
+	 * Returns whether the encoder is tuned for normal maps.
+	 *
+	 * See {@link #setNormalMap(boolean)}
+	 *
+	 * @return The setting
+	 */
+	public boolean isNormalMap() {
+		return normalMap;
+	}
+
+	/**
+	 * Set whether the encoder should be tuned for normal maps.<br>
+	 * <br>
+	 * This tunes codec parameters for better quality on normal maps. In this mode
+	 * normals are compressed to X,Y components, discarding Z component. The reader
+	 * will need to generate Z component in shaders.
+	 *
+	 * @param normalMap The setting
+	 */
+	public void setNormalMap(boolean normalMap) {
+		this.normalMap = normalMap;
+	}
+
+	/**
+	 * Returns whether the encoder optimizes for perceptual error.
+	 *
+	 * See {@link #setPerceptual(boolean)}
+	 *
+	 * @return The setting
+	 */
+	public boolean isPerceptual() {
+		return perceptual;
+	}
+
+	/**
+	 * Set whether the encoder optimizes for perceptual error.<br>
+	 * <br>
+	 * When this is <code>true</code>, then the codec should optimize for perceptual
+	 * error, instead of direct RMS error. This aims to improve perceived image
+	 * quality, but typically lowers the measured PSNR score. Perceptual methods are
+	 * currently only available for normal maps and RGB color data.
+	 *
+	 * @param perceptual The setting
+	 */
+	public void setPerceptual(boolean perceptual) {
+		this.perceptual = perceptual;
+	}
+
+	/**
+	 * Returns the swizzle that is applied to the input.<br>
+	 * <br>
+	 * Note that this will never be <code>null</code>. But it may
+	 * be an array containing the value <code>0</code> four times,
+	 * to indicate that no swizzling should be applied.<br>
+	 * <br>
+	 * Callers may not modify the returned array.<br>
+	 * <br>
+	 * See {@link #setInputSwizzle(char[])}
+	 *
+	 * @return The swizzle
+	 */
+	public char[] getInputSwizzle() {
+		return inputSwizzle;
+	}
+
+	/**
+	 * Set the swizzle that should be applied to the input.<br>
+	 * <br>
+	 * This swizzle must match the regular expression /^[rgba01]{4}$/.<br>
+	 * <br>
+	 * When the given swizzle is <code>null</code>, then no swizzling will be
+	 * applied to the input.
+	 *
+	 * @param inputSwizzle The swizzle
+	 */
+	public void setInputSwizzle(char[] inputSwizzle) {
+		if (inputSwizzle == null) {
+			this.inputSwizzle = new char[4];
+			return;
+		}
+		if (inputSwizzle.length != 4) {
+			throw new IllegalArgumentException("The inputSwizzle must contain 4 characters");
+		}
+		String valid = "rgba01";
+		for (int i = 0; i < inputSwizzle.length; i++) {
+			char c = inputSwizzle[i];
+			if (valid.indexOf(c) == -1) {
+				throw new IllegalArgumentException("The inputSwizzle may only consist of 'rgba01', but contains " + c);
+			}
+		}
+		this.inputSwizzle = inputSwizzle;
+	}
 }
diff --git a/interface/java_binding/src/main/java/org/khronos/ktx/KtxBasisParams.java b/interface/java_binding/src/main/java/org/khronos/ktx/KtxBasisParams.java
index 8749081a4a..39a5f68ce6 100644
--- a/interface/java_binding/src/main/java/org/khronos/ktx/KtxBasisParams.java
+++ b/interface/java_binding/src/main/java/org/khronos/ktx/KtxBasisParams.java
@@ -1,219 +1,705 @@
 /*
+ * Copyright (c) 2024, Khronos Group and Contributors
  * Copyright (c) 2021, Shukant Pal and Contributors
  * SPDX-License-Identifier: Apache-2.0
  */
 
 package org.khronos.ktx;
 
+/**
+ * Structure for passing parameters to {@link KtxTexture2#compressBasisEx(KtxBasisParams)}.<br>
+ * <br>
+ * At a minimum you must initialize the structure as follows:
+ * <pre><code>
+ * KtxBasisParams params = new KtxBasisParams();
+ * params.setCompressionLevel(KtxBasisParams.ETC1S_DEFAULT_COMPRESSION_LEVEL);
+ * </code></pre>
+ * The <code>compressionLevel</code> has to be explicitly set, because 0 is a valid
+ * <code>compressionLevel</code> but is not the default used by the BasisU encoder when
+ * no value is set. Only the other settings that are to be non-default must be non-zero.
+ */
 public class KtxBasisParams {
-    private boolean uastc;
-    private boolean verbose;
-    private boolean noSSE;
-    private int threadCount;
-    private int compressionLevel;
-    private int qualityLevel;
-    private int maxEndpoints;
-    private float endpointRDOThreshold;
-    private int maxSelectors;
-    private float selectorRDOThreshold;
-    private char[] inputSwizzle = new char[4];
-    private boolean normalMap;
-    private boolean preSwizzle;
-    private boolean noEndpointRDO;
-    private boolean noSelectorRDO;
-    private int uastcFlags;
-    private boolean uastcRDO;
-    private float uastcRDOQualityScalar;
-    private int uastcRDODictSize;
-    private float uastcRDOMaxSmoothBlockErrorScale;
-    private float uastcRDOMaxSmoothBlockStdDev;
-    private boolean uastcRDODontFavorSimplerModes;
-    private boolean uastcRDONoMultithreading;
-
-    public boolean isUastc() {
-        return uastc;
-    }
-
-    public void setUastc(boolean uastc) {
-        this.uastc = uastc;
-    }
-
-    public boolean isVerbose() {
-        return verbose;
-    }
-
-    public void setVerbose(boolean verbose) {
-        this.verbose = verbose;
-    }
-
-    public boolean isNoSSE() {
-        return noSSE;
-    }
-
-    public void setNoSSE(boolean noSSE) {
-        this.noSSE = noSSE;
-    }
-
-    public int getThreadCount() {
-        return threadCount;
-    }
-
-    public void setThreadCount(int threadCount) {
-        this.threadCount = threadCount;
-    }
-
-    public int getCompressionLevel() {
-        return compressionLevel;
-    }
-
-    public void setCompressionLevel(int compressionLevel) {
-        this.compressionLevel = compressionLevel;
-    }
-
-    public int getQualityLevel() {
-        return qualityLevel;
-    }
-
-    public void setQualityLevel(int qualityLevel) {
-        this.qualityLevel = qualityLevel;
-    }
-
-    public int getMaxEndpoints() {
-        return maxEndpoints;
-    }
-
-    public void setMaxEndpoints(int maxEndpoints) {
-        this.maxEndpoints = maxEndpoints;
-    }
-
-    public float getEndpointRDOThreshold() {
-        return endpointRDOThreshold;
-    }
-
-    public void setEndpointRDOThreshold(float endpointRDOThreshold) {
-        this.endpointRDOThreshold = endpointRDOThreshold;
-    }
-
-    public int getMaxSelectors() {
-        return maxSelectors;
-    }
-
-    public void setMaxSelectors(int maxSelectors) {
-        this.maxSelectors = maxSelectors;
-    }
-
-    public float getSelectorRDOThreshold() {
-        return selectorRDOThreshold;
-    }
-
-    public void setSelectorRDOThreshold(float selectorRDOThreshold) {
-        this.selectorRDOThreshold = selectorRDOThreshold;
-    }
-
-    public char[] getInputSwizzle() {
-        return inputSwizzle;
-    }
-
-    public void setInputSwizzle(char[] inputSwizzle) {
-        if (inputSwizzle.length != 4)
-            throw new IllegalArgumentException("inputSwizzle must consist of 4 bytes!");
-
-        this.inputSwizzle = inputSwizzle;
-    }
-
-    public boolean isNormalMap() {
-        return normalMap;
-    }
-
-    public void setNormalMap(boolean normalMap) {
-        this.normalMap = normalMap;
-    }
-
-    public boolean isPreSwizzle() {
-        return preSwizzle;
-    }
-
-    public void setPreSwizzle(boolean preSwizzle) {
-        this.preSwizzle = preSwizzle;
-    }
-
-    public boolean isNoEndpointRDO() {
-        return noEndpointRDO;
-    }
-
-    public void setNoEndpointRDO(boolean noEndpointRDO) {
-        this.noEndpointRDO = noEndpointRDO;
-    }
-
-    public boolean isNoSelectorRDO() {
-        return noSelectorRDO;
-    }
-
-    public void setNoSelectorRDO(boolean noSelectorRDO) {
-        this.noSelectorRDO = noSelectorRDO;
-    }
-
-    public int getUastcFlags() {
-        return uastcFlags;
-    }
-
-    public void setUastcFlags(int uastcFlags) {
-        this.uastcFlags = uastcFlags;
-    }
-
-    public boolean isUastcRDO() {
-        return uastcRDO;
-    }
-
-    public void setUastcRDO(boolean uastcRDO) {
-        this.uastcRDO = uastcRDO;
-    }
-
-    public float getUastcRDOQualityScalar() {
-        return uastcRDOQualityScalar;
-    }
-
-    public void setUastcRDOQualityScalar(float uastcRDOQualityScalar) {
-        this.uastcRDOQualityScalar = uastcRDOQualityScalar;
-    }
-
-    public int getUastcRDODictSize() {
-        return uastcRDODictSize;
-    }
-
-    public void setUastcRDODictSize(int uastcRDODictSize) {
-        this.uastcRDODictSize = uastcRDODictSize;
-    }
-
-    public float getUastcRDOMaxSmoothBlockErrorScale() {
-        return uastcRDOMaxSmoothBlockErrorScale;
-    }
-
-    public void setUastcRDOMaxSmoothBlockErrorScale(float uastcRDOMaxSmoothBlockErrorScale) {
-        this.uastcRDOMaxSmoothBlockErrorScale = uastcRDOMaxSmoothBlockErrorScale;
-    }
-
-    public float getUastcRDOMaxSmoothBlockStdDev() {
-        return uastcRDOMaxSmoothBlockStdDev;
-    }
-
-    public void setUastcRDOMaxSmoothBlockStdDev(float uastcRDOMaxSmoothBlockStdDev) {
-        this.uastcRDOMaxSmoothBlockStdDev = uastcRDOMaxSmoothBlockStdDev;
-    }
-
-    public boolean isUastcRDODontFavorSimplerModes() {
-        return uastcRDODontFavorSimplerModes;
-    }
-
-    public void setUastcRDODontFavorSimplerModes(boolean uastcRDODontFavorSimplerModes) {
-        this.uastcRDODontFavorSimplerModes = uastcRDODontFavorSimplerModes;
-    }
-
-    public boolean isUastcRDONoMultithreading() {
-        return uastcRDONoMultithreading;
-    }
 
-    public void setUastcRDONoMultithreading(boolean uastcRDONoMultithreading) {
-        this.uastcRDONoMultithreading = uastcRDONoMultithreading;
-    }
+	/**
+	 * The default compression level
+	 */
+	public static final int ETC1S_DEFAULT_COMPRESSION_LEVEL = 2;
+
+	/**
+	 * True to use UASTC base, false to use ETC1S base.
+	 */
+	private boolean uastc;
+
+	/**
+	 * Whether encoder operations are printed to standard output
+	 */
+	private boolean verbose;
+
+	/**
+	 * Whether the use of the SSE instruction set should be forbidden.
+	 */
+	private boolean noSSE;
+
+	/**
+	 * Number of threads used for the compression.
+	 */
+	private int threadCount;
+
+	/**
+	 * Encoding speed vs. quality tradeoff
+	 */
+	private int compressionLevel;
+
+	/**
+	 * Compression quality
+	 */
+	private int qualityLevel;
+
+	/**
+	 * The maximum number of color endpoint clusters
+	 */
+	private int maxEndpoints;
+
+	/**
+	 *  The endpoint RDO quality threshold
+	 */
+	private float endpointRDOThreshold;
+
+	/**
+	 * Maximum number of color selector clusters
+	 */
+	private int maxSelectors;
+
+	/**
+	 * The selector RDO threshold
+	 */
+	private float selectorRDOThreshold;
+
+	/**
+	 * The input swizzle
+	 */
+	private char[] inputSwizzle = new char[4];
+
+	/**
+	 * Whether the codec is tuned for better quality on normal maps
+	 */
+	private boolean normalMap;
+
+	/**
+	 * Whether swizzling metadata should be applied before compressing
+	 */
+	private boolean preSwizzle;
+
+	/**
+	 * Disable endpoint rate distortion optimizations
+	 */
+	private boolean noEndpointRDO;
+
+	/**
+	 * Disable selector rate distortion optimizations
+	 */
+	private boolean noSelectorRDO;
+
+	/**
+	 * The flag bits controlling UASTC encoding
+	 */
+	private int uastcFlags;
+
+	/**
+	 * Whether rate distortion optimization (RDO) post-processing is enabled
+	 */
+	private boolean uastcRDO;
+
+	/**
+	 * The UASTC RDO quality scalar
+	 */
+	private float uastcRDOQualityScalar;
+
+	/**
+	 * The UASTC RDO dictionary size in bytes
+	 */
+	private int uastcRDODictSize;
+
+	/**
+	 * The UASTC RDO maximum smooth block error scale
+	 */
+	private float uastcRDOMaxSmoothBlockErrorScale;
+
+	/**
+	 * The UASTC RDO maximum smooth block standard deviation.
+	 */
+	private float uastcRDOMaxSmoothBlockStdDev;
+
+	/**
+	 * Do not favor simpler UASTC modes in RDO mode.
+	 */
+	private boolean uastcRDODontFavorSimplerModes;
+
+	/**
+	 * Disable RDO multithreading.
+	 */
+	private boolean uastcRDONoMultithreading;
+
+	/**
+	 * Returns whether UASTC base is set.
+	 *
+	 * See {@link #setUastc(boolean)}
+	 *
+	 * @return The setting
+	 */
+	public boolean isUastc() {
+		return uastc;
+	}
+
+	/**
+	 * Set whether to use UASTC base.<br>
+	 * <br>
+	 * Setting this to <code>false</code> will use ETC1S base.
+	 *
+	 * @param uastc The setting
+	 */
+	public void setUastc(boolean uastc) {
+		this.uastc = uastc;
+	}
+
+	/**
+	 * Returns whether encoder operations are printed to standard output.
+	 *
+	 * See {@link #setVerbose(boolean)}.
+	 *
+	 * @return The setting
+	 */
+	public boolean isVerbose() {
+		return verbose;
+	}
+
+	/**
+	 * Set whether Basis Universal encoder operation details are printed to the
+	 * standard output. <br>
+	 * <br>
+	 * Not recommended for GUI apps.
+	 *
+	 * @param verbose The setting
+	 */
+	public void setVerbose(boolean verbose) {
+		this.verbose = verbose;
+	}
+
+	/**
+	 * Returns whether the use of the SSE instruction set is forbidden.
+	 *
+	 * See {@link #setNoSSE(boolean)}
+	 *
+	 * @return The setting
+	 */
+	public boolean isNoSSE() {
+		return noSSE;
+	}
+
+	/**
+	 * Set whether the use of the SSE instruction set should be forbidden.<br>
+	 * <br>
+	 * Ignored if CPU does not support SSE.
+	 *
+	 * @param noSSE The setting
+	 */
+	public void setNoSSE(boolean noSSE) {
+		this.noSSE = noSSE;
+	}
+
+	/**
+	 * Returns the number of threads used for compression.
+	 *
+	 * See {@link #setThreadCount(int)}
+	 *
+	 * @return The thread count
+	 */
+	public int getThreadCount() {
+		return threadCount;
+	}
+
+	/**
+	 * Set the number of threads used for compression.<br>
+	 * <br>
+	 * Default is 1.
+	 *
+	 * @param threadCount The thread count
+	 */
+	public void setThreadCount(int threadCount) {
+		this.threadCount = threadCount;
+	}
+
+	/**
+	 * Returns the encoding speed versus quality tradeoff.
+	 *
+	 * See {@link #setCompressionLevel(int)}
+	 *
+	 * @return The compression level
+	 */
+	public int getCompressionLevel() {
+		return compressionLevel;
+	}
+
+	/**
+	 * Set the encoding speed versus quality tradeoff.<br>
+	 * <br>
+	 * The range is [0,5]. Higher values are slower, but give higher quality.
+	 * There is no default. Callers must explicitly set this value. Callers
+	 * can use {@link #ETC1S_DEFAULT_COMPRESSION_LEVEL} as a default value.
+	 * Currently this is 2.
+	 *
+	 * @param compressionLevel The compression level
+	 */
+	public void setCompressionLevel(int compressionLevel) {
+		this.compressionLevel = compressionLevel;
+	}
+
+	/**
+	 * Returns the compression quality.
+	 *
+	 * See {@link #setQualityLevel(int)}
+	 *
+	 * @return The compression quality
+	 */
+	public int getQualityLevel() {
+		return qualityLevel;
+	}
+
+	/**
+	 * Set the compression quality.<br>
+	 * <br>
+	 * The range is [1,255]. Lower gives better compression/lower quality/faster.
+	 * Higher gives less compression/higher quality/slower.<br>
+	 * <br>
+	 * This automatically determines values for <code>maxEndpoints</code>,
+	 * <code>maxSelectors</code>, <code>endpointRDOThreshold</code> and
+	 * <code>selectorRDOThreshold</code> for the target quality level.
+	 * Setting these parameters overrides the values determined by
+	 * <code>qualityLevel</code>, which defaults to 128 if neither it nor
+	 * both of <code>maxEndpoints</code> and <code>maxSelectors</code> have been set.<br>
+	 * <br>
+	 * <b>Note:</b><br>
+	 * <br>
+	 * Both of <code>maxEndpoints</code> and <code>maxSelectors</code> must be
+	 * set for them to have any effect. The <code>qualityLevel</code> will only
+	 * determine values for <code>endpointRDOThreshold</code> and
+	 * <code>selectorRDOThreshold</code> when its value exceeds 128, otherwise
+	 * their defaults will be used.
+	 *
+	 * @param qualityLevel The compression quality
+	 */
+	public void setQualityLevel(int qualityLevel) {
+		this.qualityLevel = qualityLevel;
+	}
+
+	/**
+	 * Returns the maximum number of color endpoint clusters.
+	 *
+	 * See {@link #setMaxEndpoints(int)}
+	 *
+	 * @return The maximum number of endpoints
+	 */
+	public int getMaxEndpoints() {
+		return maxEndpoints;
+	}
+
+	/**
+	 * Set the maximum number of color endpoint clusters.<br>
+	 * <br>
+	 * Range is [1,16128]. Default is 0, unset. If this is set, <code>maxSelectors</code>
+	 * must also be set, otherwise the value will be ignored.
+	 *
+	 * @param maxEndpoints The maximum number of color endpoint clusters
+	 */
+	public void setMaxEndpoints(int maxEndpoints) {
+		this.maxEndpoints = maxEndpoints;
+	}
+
+	/**
+	 * Returns the endpoint RDO threshold.
+	 *
+	 * See {@link #setEndpointRDOThreshold(float)}
+	 *
+	 * @return The threshold
+	 */
+	public float getEndpointRDOThreshold() {
+		return endpointRDOThreshold;
+	}
+
+	/**
+	 * Set the endpoint RDO quality threshold.<br>
+	 * <br>
+	 * (RDO stands for "rate distortion optimizations")<br>
+	 * <br>
+	 * The default is 1.25. Lower is higher quality but less quality per
+	 * output bit (try [1.0,3.0]). This will override the value
+	 * chosen by <code>qualityLevel</code>.
+	 *
+	 * @param endpointRDOThreshold The threshold
+	 */
+	public void setEndpointRDOThreshold(float endpointRDOThreshold) {
+		this.endpointRDOThreshold = endpointRDOThreshold;
+	}
+
+	/**
+	 * Returns the maximum number of color selector clusters.
+	 *
+	 * See {@link #setMaxEndpoints(int)}
+	 *
+	 * @return The maximum number of color selector clusters
+	 */
+	public int getMaxSelectors() {
+		return maxSelectors;
+	}
+
+	/**
+	 * Set the maximum number of color selector clusters.<br>
+	 * <br>
+	 * Range is [1,16128]. Default is 0, unset. If this is set,
+	 * <code>maxEndpoints</code> must also be set, otherwise the value will be ignored.
+	 *
+	 * @param maxSelectors The maximum number of color selector clusters
+	 */
+	public void setMaxSelectors(int maxSelectors) {
+		this.maxSelectors = maxSelectors;
+	}
+
+	/**
+	 * Returns the selector RDO threshold.
+	 *
+	 * See {@link #setSelectorRDOThreshold(float)}
+	 *
+	 * @return The selector RDO threshold
+	 */
+	public float getSelectorRDOThreshold() {
+		return selectorRDOThreshold;
+	}
+
+	/**
+	 * Set the selector RDO quality threshold.<br>
+	 * <br>
+	 * (RDO stands for "rate distortion optimizations")<br>
+	 * <br>
+	 * The default is 1.5. Lower is higher quality but less quality per output
+	 * bit (try [1.0,3.0]). This will override the value chosen by
+	 * <code>qualityLevel</code>.
+	 *
+	 * @param selectorRDOThreshold The selector RDO threshold.
+	 */
+	public void setSelectorRDOThreshold(float selectorRDOThreshold) {
+		this.selectorRDOThreshold = selectorRDOThreshold;
+	}
+
+	/**
+	 * Returns the swizzle that is applied to the input.<br>
+	 * <br>
+	 * Note that this will never be <code>null</code>. But it may
+	 * be an array containing the value <code>0</code> four times,
+	 * to indicate that no swizzling should be applied.<br>
+	 * <br>
+	 * Callers may not modify the returned array.<br>
+	 * <br>
+	 * See {@link #setInputSwizzle(char[])}
+	 *
+	 * @return The swizzle
+	 */
+	public char[] getInputSwizzle() {
+		return inputSwizzle;
+	}
+
+	/**
+	 * Set the swizzle that should be applied to the input.<br>
+	 * <br>
+	 * This swizzle must match the regular expression /^[rgba01]{4}$/.<br>
+	 * <br>
+	 * When the given swizzle is <code>null</code>, then no swizzling will be
+	 * applied to the input.
+	 *
+	 * @param inputSwizzle The swizzle
+	 */
+	public void setInputSwizzle(char[] inputSwizzle) {
+		if (inputSwizzle == null) {
+			this.inputSwizzle = new char[4];
+			return;
+		}
+		if (inputSwizzle.length != 4) {
+			throw new IllegalArgumentException("The inputSwizzle must contain 4 characters");
+		}
+		String valid = "rgba01";
+		for (int i = 0; i < inputSwizzle.length; i++) {
+			char c = inputSwizzle[i];
+			if (valid.indexOf(c) == -1) {
+				throw new IllegalArgumentException("The inputSwizzle may only consist of 'rgba01', but contains " + c);
+			}
+		}
+		this.inputSwizzle = inputSwizzle;
+	}
+
+	/**
+	 * Returns whether the codec is tuned for better quality on normal maps.
+	 *
+	 * See {@link #setNormalMap(boolean)}
+	 *
+	 * @return The setting
+	 */
+	public boolean isNormalMap() {
+		return normalMap;
+	}
+
+	/**
+	 * Set whether the codec should be tuned for better quality on normal maps.<br>
+	 * <br>
+	 * When this is <code>true</code>, then it will use no selector RDO, no endpoint RDO,
+	 * and set the texture's DFD appropriately. Only valid for linear textures.
+	 *
+	 * @param normalMap The setting
+	 */
+	public void setNormalMap(boolean normalMap) {
+		this.normalMap = normalMap;
+	}
+
+	/**
+	 * Whether swizzling metadata should be applied before compressing.
+	 *
+	 * See {@link #setPreSwizzle(boolean)}
+	 *
+	 * @return The setting
+	 */
+	public boolean isPreSwizzle() {
+		return preSwizzle;
+	}
+
+	/**
+	 * Set whether swizzling metadata should be applied before compressing.<br>
+	 * <br>
+	 * If the texture has <code>KTXswizzle</code> metadata, apply it before
+	 * compressing. Swizzling, like <code>rabb</code> may yield drastically
+	 * different error metrics if done after supercompression.
+	 *
+	 * @param preSwizzle The setting
+	 */
+	public void setPreSwizzle(boolean preSwizzle) {
+		this.preSwizzle = preSwizzle;
+	}
+
+	/**
+	 * Returns whether endpoint rate distortion optimizations are disabled.
+	 *
+	 * See {@link #setNoEndpointRDO(boolean)}
+	 *
+	 * @return The setting
+	 */
+	public boolean isNoEndpointRDO() {
+		return noEndpointRDO;
+	}
+
+	/**
+	 * Set whether endpoint rate distortion optimizations should be disabled.<br>
+	 * <br>
+	 * Setting this to <code>true</code> will yield slightly faster, less noisy
+	 * output, but lower quality per output bit. Default is <code>false</code>.
+	 *
+	 * @param noEndpointRDO The setting
+	 */
+	public void setNoEndpointRDO(boolean noEndpointRDO) {
+		this.noEndpointRDO = noEndpointRDO;
+	}
+
+	/**
+	 * Returns whether selector rate distortion optimizations are disabled.
+	 *
+	 * See {@link #setNoSelectorRDO(boolean)}
+	 *
+	 * @return The setting
+	 */
+	public boolean isNoSelectorRDO() {
+		return noSelectorRDO;
+	}
+
+	/**
+	 * Set whether selector rate distortion optimizations are disabled.<br>
+	 * <br>
+	 * Setting this to <code>true</code> will yield slightly faster, less noisy
+	 * output, but lower quality per output bit. Default is <code>false</code>.
+	 *
+	 * @param noSelectorRDO The setting
+	 */
+	public void setNoSelectorRDO(boolean noSelectorRDO) {
+		this.noSelectorRDO = noSelectorRDO;
+	}
+
+	/**
+	 * Returns the {@link KtxPackUastcFlagBits}
+	 *
+	 * See {@link #setUastcFlags(int)}
+	 *
+	 * @return The flag bits
+	 */
+	public int getUastcFlags() {
+		return uastcFlags;
+	}
+
+	/**
+	 * Set the {@link KtxPackUastcFlagBits}.<br>
+	 * <br>
+	 * The most important value is the level given in the least-significant 4 bits
+	 * of the respective constant, which selects a speed versus quality tradeoff.
+	 *
+	 * @param uastcFlags The flag bits
+	 */
+	public void setUastcFlags(int uastcFlags) {
+		this.uastcFlags = uastcFlags;
+	}
+
+	/**
+	 * Returns whether rate distortion optimization (RDO) post-processing is enabled.
+	 *
+	 * @return The setting
+	 */
+	public boolean isUastcRDO() {
+		return uastcRDO;
+	}
+
+	/**
+	 * Set whether rate distortion optimization (RDO) post-processing is enabled.
+	 *
+	 * @param uastcRDO The setting
+	 */
+	public void setUastcRDO(boolean uastcRDO) {
+		this.uastcRDO = uastcRDO;
+	}
+
+	/**
+	 * Returns the UASTC quality scalar.
+	 *
+	 * See {@link #setUastcRDOQualityScalar(float)}
+	 *
+	 * @return The quality scalar
+	 */
+	public float getUastcRDOQualityScalar() {
+		return uastcRDOQualityScalar;
+	}
+
+	/**
+	 * Set the UASTC quality scalar.
+	 *
+	 * This sets the quality scalar ("lambda"). Lower values yield higher quality/larger LZ
+	 * compressed files, higher values yield lower quality/smaller LZ compressed files.
+	 * A good range to try is [.2,4]. Full range is [.001,50.0]. Default is 1.0.
+	 *
+	 * @param uastcRDOQualityScalar The quality scalar.
+	 */
+	public void setUastcRDOQualityScalar(float uastcRDOQualityScalar) {
+		this.uastcRDOQualityScalar = uastcRDOQualityScalar;
+	}
+
+	/**
+	 * Returns the UASTC RDO dictionary size in bytes.
+	 *
+	 * See {@link #setUastcRDODictSize(int)}
+	 *
+	 * @return The dictionary size
+	 */
+	public int getUastcRDODictSize() {
+		return uastcRDODictSize;
+	}
+
+	/**
+	 * Set the UASTC RDO dictionary size in bytes. <br>
+	 * <br>
+	 * The default is 4096. Lower values=faster, but give less
+	 * compression. Range is [64,65536].
+	 *
+	 * @param uastcRDODictSize The dictionary size
+	 */
+	public void setUastcRDODictSize(int uastcRDODictSize) {
+		this.uastcRDODictSize = uastcRDODictSize;
+	}
+
+	/**
+	 * Returns the UASTC RDO maximum smooth block error scale.
+	 *
+	 * See {@link #setUastcRDOMaxSmoothBlockErrorScale(float)}
+	 *
+	 * @return The error scale
+	 */
+	public float getUastcRDOMaxSmoothBlockErrorScale() {
+		return uastcRDOMaxSmoothBlockErrorScale;
+	}
+
+	/**
+	 * Set the UASTC RDO maximum smooth block error scale.<br>
+	 * <br>
+	 * Range is [1,300]. Default is 10.0, 1.0 is disabled. Larger values
+	 * suppress more artifacts (and allocate more bits) on smooth blocks.
+	 *
+	 * @param uastcRDOMaxSmoothBlockErrorScale The error scale
+	 */
+	public void setUastcRDOMaxSmoothBlockErrorScale(float uastcRDOMaxSmoothBlockErrorScale) {
+		this.uastcRDOMaxSmoothBlockErrorScale = uastcRDOMaxSmoothBlockErrorScale;
+	}
+
+	/**
+	 * Returns the UASTC RDO maximum smooth block standard deviation.
+	 *
+	 * See {@link #setUastcRDOMaxSmoothBlockStdDev(float)}
+	 *
+	 * @return The standard deviation
+	 */
+	public float getUastcRDOMaxSmoothBlockStdDev() {
+		return uastcRDOMaxSmoothBlockStdDev;
+	}
+
+	/**
+	 * Set the UASTC RDO maximum smooth block standard deviation.<br>
+	 * <br>
+	 * Range is [.01,65536.0]. Default is 18.0. Larger values expand the range
+	 * of blocks considered smooth.
+	 *
+	 * @param uastcRDOMaxSmoothBlockStdDev The standard deviation
+	 */
+	public void setUastcRDOMaxSmoothBlockStdDev(float uastcRDOMaxSmoothBlockStdDev) {
+		this.uastcRDOMaxSmoothBlockStdDev = uastcRDOMaxSmoothBlockStdDev;
+	}
+
+	/**
+	 * Returns whether to <b>not</b> favor simpler UASTC modes in RDO mode.
+	 *
+	 * @return The setting
+	 */
+	public boolean isUastcRDODontFavorSimplerModes() {
+		return uastcRDODontFavorSimplerModes;
+	}
+
+	/**
+	 * Set whether to <b>not</b> favor simpler UASTC modes in RDO mode.
+	 *
+	 * @param uastcRDODontFavorSimplerModes The setting
+	 */
+	public void setUastcRDODontFavorSimplerModes(boolean uastcRDODontFavorSimplerModes) {
+		this.uastcRDODontFavorSimplerModes = uastcRDODontFavorSimplerModes;
+	}
+
+	/**
+	 * Returns whether UASTC RDO multithreading is disabled.
+	 *
+	 * See {@link #setUastcRDONoMultithreading(boolean)}
+	 *
+	 * @return The setting
+	 */
+	public boolean isUastcRDONoMultithreading() {
+		return uastcRDONoMultithreading;
+	}
+
+	/**
+	 * Set whether RDO multithreading is disabled.<br>
+	 * <br>
+	 * Setting this to <code>true</code> will yield slightly higher compression,
+	 * and be deterministic.
+	 *
+	 * @param uastcRDONoMultithreading The setting
+	 */
+	public void setUastcRDONoMultithreading(boolean uastcRDONoMultithreading) {
+		this.uastcRDONoMultithreading = uastcRDONoMultithreading;
+	}
 }
diff --git a/interface/java_binding/src/main/java/org/khronos/ktx/KtxCreateStorage.java b/interface/java_binding/src/main/java/org/khronos/ktx/KtxCreateStorage.java
deleted file mode 100644
index 37ced3780a..0000000000
--- a/interface/java_binding/src/main/java/org/khronos/ktx/KtxCreateStorage.java
+++ /dev/null
@@ -1,11 +0,0 @@
-/*
- * Copyright (c) 2021, Shukant Pal and Contributors
- * SPDX-License-Identifier: Apache-2.0
- */
-
-package org.khronos.ktx;
-
-public class KtxCreateStorage {
-    public static final int NO = 0;
-    public static final int ALLOC = 1;
-}
diff --git a/interface/java_binding/src/main/java/org/khronos/ktx/KtxErrorCode.java b/interface/java_binding/src/main/java/org/khronos/ktx/KtxErrorCode.java
index f25527bdc5..a2b99c0f8d 100644
--- a/interface/java_binding/src/main/java/org/khronos/ktx/KtxErrorCode.java
+++ b/interface/java_binding/src/main/java/org/khronos/ktx/KtxErrorCode.java
@@ -1,32 +1,196 @@
 /*
+ * Copyright (c) 2024, Khronos Group and Contributors
  * Copyright (c) 2021, Shukant Pal and Contributors
  * SPDX-License-Identifier: Apache-2.0
  */
 
 package org.khronos.ktx;
 
-/** Error codes returned from KTX functions as "int". */
+/**
+ * Error codes returned from KTX functions as "int"
+ */
 public class KtxErrorCode {
-    public static final int SUCCESS = 0;
-    public static final int FILE_DATA_ERROR = 1;
-    public static final int FILE_ISPIPE = 2;
-    public static final int FILE_OPEN_FAILED = 3;
-    public static final int FILE_OVERFLOW = 4;
-    public static final int FILE_READ_ERROR = 5;
-    public static final int FILE_SEEK_ERROR = 6;
-    public static final int FILE_UNEXPECTED_EOF = 7;
-    public static final int FILE_WRITE_ERROR = 8;
-    public static final int GL_ERROR = 9;
-    public static final int INVALID_OPERATION = 10;
-    public static final int INVALID_VALUE = 11;
-    public static final int NOT_FOUND = 12;
-    public static final int OUT_OF_MEMORY = 13;
-    public static final int TRANSCODE_FAILED = 14;
-    public static final int UNKNOWN_FILE_FORMAT = 15;
-    public static final int UNSUPPORTED_TEXTURE_TYPE = 16;
-    public static final int UNSUPPORTED_FEATURE = 17;
-    public static final int LIBRARY_NOT_LINKED = 18;
-    public static final int DECOMPRESS_LENGTH_ERROR = 19;
-    public static final int DECOMPRESS_CHECKSUM_ERROR = 20;
-    public static final int ERROR_MAX_ENUM = DECOMPRESS_CHECKSUM_ERROR;
+
+	/**
+	 * Operation was successful
+	 */
+	public static final int SUCCESS = 0;
+
+	/**
+	 * The data in the file is inconsistent with the spec
+	 */
+	public static final int FILE_DATA_ERROR = 1;
+
+	/**
+	 * The file is a pipe or named pipe
+	 */
+	public static final int FILE_ISPIPE = 2;
+
+	/**
+	 * The target file could not be opened
+	 */
+	public static final int FILE_OPEN_FAILED = 3;
+
+	/**
+	 * The operation would exceed the max file size
+	 */
+	public static final int FILE_OVERFLOW = 4;
+
+	/**
+	 * An error occurred while reading from the file
+	 */
+	public static final int FILE_READ_ERROR = 5;
+
+	/**
+	 * An error occurred while seeking in the file
+	 */
+	public static final int FILE_SEEK_ERROR = 6;
+
+	/**
+	 * File does not have enough data to satisfy request
+	 */
+	public static final int FILE_UNEXPECTED_EOF = 7;
+
+	/**
+	 * An error occurred while writing to the file
+	 */
+	public static final int FILE_WRITE_ERROR = 8;
+
+	/**
+	 * GL operations resulted in an error
+	 */
+	public static final int GL_ERROR = 9;
+
+	/**
+	 * The operation is not allowed in the current state
+	 */
+	public static final int INVALID_OPERATION = 10;
+
+	/**
+	 * A parameter value was not valid
+	 */
+	public static final int INVALID_VALUE = 11;
+
+	/**
+	 * Requested metadata key or required dynamically loaded GPU function was not
+	 * found
+	 */
+	public static final int NOT_FOUND = 12;
+
+	/**
+	 * Not enough memory to complete the operation
+	 */
+	public static final int OUT_OF_MEMORY = 13;
+
+	/**
+	 * Transcoding of block compressed texture failed
+	 */
+	public static final int TRANSCODE_FAILED = 14;
+
+	/**
+	 * The file not a KTX file
+	 */
+	public static final int UNKNOWN_FILE_FORMAT = 15;
+
+	/**
+	 * The KTX file specifies an unsupported texture type
+	 */
+	public static final int UNSUPPORTED_TEXTURE_TYPE = 16;
+
+	/**
+	 * Feature not included in in-use library or not yet implemented
+	 */
+	public static final int UNSUPPORTED_FEATURE = 17;
+
+	/**
+	 * Library dependency (OpenGL or Vulkan) not linked into application
+	 */
+	public static final int LIBRARY_NOT_LINKED = 18;
+
+	/**
+	 * Decompressed byte count does not match expected byte size
+	 */
+	public static final int DECOMPRESS_LENGTH_ERROR = 19;
+
+	/**
+	 * Checksum mismatch when decompressing
+	 */
+	public static final int DECOMPRESS_CHECKSUM_ERROR = 20;
+
+	/**
+	 * For safety checks
+	 */
+	public static final int MAX_ENUM = DECOMPRESS_CHECKSUM_ERROR;
+
+	/**
+	 * Returns a string representation of the given error code
+	 *
+	 * @param n The error code
+	 * @return A string representation of the given error code
+	 */
+	public static String stringFor(int n) {
+		switch (n) {
+		case SUCCESS:
+			return "SUCCESS";
+		case FILE_DATA_ERROR:
+			return "FILE_DATA_ERROR";
+		case FILE_ISPIPE:
+			return "FILE_ISPIPE";
+		case FILE_OPEN_FAILED:
+			return "FILE_OPEN_FAILED";
+		case FILE_OVERFLOW:
+			return "FILE_OVERFLOW";
+		case FILE_READ_ERROR:
+			return "FILE_READ_ERROR";
+		case FILE_SEEK_ERROR:
+			return "FILE_SEEK_ERROR";
+		case FILE_UNEXPECTED_EOF:
+			return "FILE_UNEXPECTED_EOF";
+		case FILE_WRITE_ERROR:
+			return "FILE_WRITE_ERROR";
+		case GL_ERROR:
+			return "GL_ERROR";
+		case INVALID_OPERATION:
+			return "INVALID_OPERATION";
+		case INVALID_VALUE:
+			return "INVALID_VALUE";
+		case NOT_FOUND:
+			return "NOT_FOUND";
+		case OUT_OF_MEMORY:
+			return "OUT_OF_MEMORY";
+		case TRANSCODE_FAILED:
+			return "TRANSCODE_FAILED";
+		case UNKNOWN_FILE_FORMAT:
+			return "UNKNOWN_FILE_FORMAT";
+		case UNSUPPORTED_TEXTURE_TYPE:
+			return "UNSUPPORTED_TEXTURE_TYPE";
+		case UNSUPPORTED_FEATURE:
+			return "UNSUPPORTED_FEATURE";
+		case LIBRARY_NOT_LINKED:
+			return "LIBRARY_NOT_LINKED";
+		case DECOMPRESS_LENGTH_ERROR:
+			return "DECOMPRESS_LENGTH_ERROR";
+		case DECOMPRESS_CHECKSUM_ERROR:
+			return "DECOMPRESS_CHECKSUM_ERROR";
+		}
+		return "[Unknown KtxErrorCode]";
+	}
+
+	/**
+	 * Return a string corresponding to a KTX error code.
+	 *
+	 * @param error The error code for which to return a string
+     * @return The message string.
+	 */
+	public static native String createString(int error);
+
+
+	/**
+	 * Private constructor to prevent instantiation
+	 */
+	private KtxErrorCode() {
+		// Prevent instantiation
+	}
+
+
 }
diff --git a/interface/java_binding/src/main/java/org/khronos/ktx/KtxException.java b/interface/java_binding/src/main/java/org/khronos/ktx/KtxException.java
new file mode 100644
index 0000000000..b021c94683
--- /dev/null
+++ b/interface/java_binding/src/main/java/org/khronos/ktx/KtxException.java
@@ -0,0 +1,43 @@
+/*
+ * Copyright (c) 2024, Khronos Group and Contributors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+package org.khronos.ktx;
+
+/**
+ * An exception that may be thrown due to a KTX error. <br>
+ * <br>
+ * This will be thrown from methods like the <code>KtxTexture2#create...</code>
+ * methods or {@link KtxTexture2#writeToMemory()} in the case that the
+ * underlying implementation caused an error code that was not
+ * {@link KtxErrorCode#SUCCESS}.
+ */
+public class KtxException extends RuntimeException
+{
+	/**
+	 * Serial UID
+	 */
+	private static final long serialVersionUID = 313517353875035541L;
+
+	/**
+	 * Creates a new KtxException with the given error message.
+	 *
+	 * @param message The error message for this KtxException
+	 */
+	public KtxException(String message)
+	{
+		super(message);
+	}
+
+	/**
+	 * Creates a new KtxException with the given error message
+	 * and the given Throwable as the cause.
+	 *
+	 * @param message The error message for this KtxException
+	 * @param cause The reason for this KtxException
+	 */
+	public KtxException(String message, Throwable cause)
+	{
+		super(message, cause);
+	}
+}
\ No newline at end of file
diff --git a/interface/java_binding/src/main/java/org/khronos/ktx/KtxInternalformat.java b/interface/java_binding/src/main/java/org/khronos/ktx/KtxInternalformat.java
index 442bdde418..ebcc60bef4 100644
--- a/interface/java_binding/src/main/java/org/khronos/ktx/KtxInternalformat.java
+++ b/interface/java_binding/src/main/java/org/khronos/ktx/KtxInternalformat.java
@@ -1,10 +1,15 @@
 /*
  * Copyright (c) 2021, Shukant Pal and Contributors
+ * Copyright (c) 2024, Khronos Group and Contributors
  * SPDX-License-Identifier: Apache-2.0
  */
 
 package org.khronos.ktx;
 
+/**
+ * Constants that can be set as the internal format in
+ * {@link KtxTextureCreateInfo#setGlInternalformat(int)}.
+ */
 public class KtxInternalformat {
     public static final int GL_R3_G3_B2                       = 0x2A10;
     public static final int GL_RGB4                           = 0x804F;
diff --git a/interface/java_binding/src/main/java/org/khronos/ktx/KtxPackAstcBlockDimension.java b/interface/java_binding/src/main/java/org/khronos/ktx/KtxPackAstcBlockDimension.java
index 7ea9650aa5..c92b24638f 100644
--- a/interface/java_binding/src/main/java/org/khronos/ktx/KtxPackAstcBlockDimension.java
+++ b/interface/java_binding/src/main/java/org/khronos/ktx/KtxPackAstcBlockDimension.java
@@ -1,34 +1,179 @@
 /*
+ * Copyright (c) 2024, Khronos Group and Contributors
  * Copyright (c) 2021, Shukant Pal and Contributors
  * SPDX-License-Identifier: Apache-2.0
  */
 
 package org.khronos.ktx;
 
+/**
+ * Options specifying ASTC encoding block dimensions
+ */
 public class KtxPackAstcBlockDimension {
+
+	/**
+	 * 8.00 bpp
+	 */
     public static final int D4x4 = 0;
+
+    /**
+     * 6.40 bpp
+     */
     public static final int D5x4 = 1;
+
+    /**
+     * 5.12 bpp
+     */
     public static final int D5x5 = 2;
+
+    /**
+     * 4.27 bpp
+     */
     public static final int D6x4 = 3;
+
+    /**
+     * 3.56 bpp
+     */
     public static final int D6x6 = 4;
+
+    /**
+     * 3.20 bpp
+     */
     public static final int D8x5 = 5;
+
+    /**
+     * 2.67 bpp
+     */
     public static final int D8x6 = 6;
+
+    /**
+     * 2.56 bpp
+     */
     public static final int D10x5 = 7;
+
+    /**
+     * 2.13 bpp
+     */
     public static final int D10x6 = 8;
+
+    /**
+     * 2.00 bpp
+     */
     public static final int D8x8 = 9;
+
+    /**
+     * 1.60 bpp
+     */
     public static final int D10x8 = 10;
+
+    /**
+     * 1.28 bpp
+     */
     public static final int D10x10 = 11;
+
+    /**
+     * 1.07 bpp
+     */
     public static final int D12x10 = 12;
+
+    /**
+     * 0.89 bpp
+     */
     public static final int D12x12 = 13;
 
+    /**
+     * 4.74 bpp
+     */
     public static final int D3x3x3 = 14;
+
+    /**
+     * 3.56 bpp
+     */
     public static final int D4x3x3 = 15;
+
+    /**
+     * 2.67 bpp
+     */
     public static final int D4x4x3 = 16;
+
+    /**
+     * 2.00 bpp
+     */
     public static final int D4x4x4 = 17;
+
+    /**
+     * 1.60 bpp
+     */
     public static final int D5x4x4 = 18;
+
+    /**
+     * 1.28 bpp
+     */
     public static final int D5x5x4 = 19;
+
+    /**
+     * 1.02 bpp
+     */
     public static final int D5x5x5 = 20;
+
+    /**
+     * 0.85 bpp
+     */
     public static final int D6x5x5 = 21;
+
+    /**
+     * 0.71 bpp
+     */
     public static final int D6x6x5 = 22;
+
+    /**
+     *  0.59 bpp
+     */
     public static final int D6x6x6 = 23;
+
+	/**
+	 * Returns a string representation of the given block dimensions
+	 *
+	 * @param n The block dimensions
+	 * @return A string representation of the given block dimensions
+	 */
+	public static String stringFor(int n) {
+		switch (n) {
+		case D4x4: return "D4x4";
+		case D5x4: return "D5x4";
+		case D5x5: return "D5x5";
+		case D6x4: return "D6x4";
+		case D6x6: return "D6x6";
+		case D8x5: return "D8x5";
+		case D8x6: return "D8x6";
+		case D10x5: return "D10x5";
+		case D10x6: return "D10x6";
+		case D8x8: return "D8x8";
+		case D10x8: return "D10x8";
+		case D10x10: return "D10x10";
+		case D12x10: return "D12x10";
+		case D12x12: return "D12x12";
+
+		case D3x3x3: return "D3x3x3";
+		case D4x3x3: return "D4x3x3";
+		case D4x4x3: return "D4x4x3";
+		case D4x4x4: return "D4x4x4";
+		case D5x4x4: return "D5x4x4";
+		case D5x5x4: return "D5x5x4";
+		case D5x5x5: return "D5x5x5";
+		case D6x5x5: return "D6x5x5";
+		case D6x6x5: return "D6x6x5";
+		case D6x6x6: return "D6x6x6";
+		}
+		return "[Unknown KtxPackAstcBlockDimension]";
+	}
+
+	/**
+	 * Private constructor to prevent instantiation
+	 */
+	private KtxPackAstcBlockDimension() {
+		// Prevent instantiation
+	}
+
+
 }
diff --git a/interface/java_binding/src/main/java/org/khronos/ktx/KtxPackAstcEncoderMode.java b/interface/java_binding/src/main/java/org/khronos/ktx/KtxPackAstcEncoderMode.java
index bf8fa6e1bc..1e8404e040 100644
--- a/interface/java_binding/src/main/java/org/khronos/ktx/KtxPackAstcEncoderMode.java
+++ b/interface/java_binding/src/main/java/org/khronos/ktx/KtxPackAstcEncoderMode.java
@@ -1,12 +1,43 @@
 /*
+ * Copyright (c) 2024, Khronos Group and Contributors
  * Copyright (c) 2021, Shukant Pal and Contributors
  * SPDX-License-Identifier: Apache-2.0
  */
 
 package org.khronos.ktx;
 
+/**
+ * Options specifying ASTC encoder profile mode.<br>
+ * <br>
+ * These constants can be passed to the {@link KtxAstcParams#setMode(int)}
+ * function.
+ */
 public class KtxPackAstcEncoderMode {
     public static final int DEFAULT = 0;
     public static final int LDR = 1;
     public static final int HDR = 2;
+
+	/**
+	 * Returns a string representation of the given encoder mode
+	 *
+	 * @param n The encoder mode
+	 * @return A string representation of the given encoder mode
+	 */
+	public static String stringFor(int n) {
+		switch (n) {
+		case DEFAULT: return "DEFAULT";
+		case LDR: return "LDR";
+		case HDR: return "HDR";
+		}
+		return "[Unknown KtxPackAstcEncoderMode]";
+	}
+
+	/**
+	 * Private constructor to prevent instantiation
+	 */
+	private KtxPackAstcEncoderMode() {
+		// Prevent instantiation
+	}
+
+
 }
diff --git a/interface/java_binding/src/main/java/org/khronos/ktx/KtxPackAstcQualityLevel.java b/interface/java_binding/src/main/java/org/khronos/ktx/KtxPackAstcQualityLevel.java
index 9e8999a79f..498415d308 100644
--- a/interface/java_binding/src/main/java/org/khronos/ktx/KtxPackAstcQualityLevel.java
+++ b/interface/java_binding/src/main/java/org/khronos/ktx/KtxPackAstcQualityLevel.java
@@ -1,14 +1,66 @@
 /*
+ * Copyright (c) 2024, Khronos Group and Contributors
  * Copyright (c) 2021, Shukant Pal and Contributors
  * SPDX-License-Identifier: Apache-2.0
  */
 
 package org.khronos.ktx;
 
+/**
+ * Options specifying ASTC encoding quality levels.<br>
+ * <br>
+ * These constants can be passed to {@link KtxAstcParams#setQualityLevel(int)}.
+ */
 public class KtxPackAstcQualityLevel {
-    public static final int FASTEST = 0;
-    public static final int FAST = 10;
-    public static final int MEDIUM = 60;
-    public static final int THOROUGH = 98;
-    public static final int EXHAUSTIVE = 100;
+
+	/**
+	 * Fastest compression
+	 */
+	public static final int FASTEST = 0;
+
+	/**
+	 * Fast compression
+	 */
+	public static final int FAST = 10;
+
+	/**
+	 * Medium compression
+	 */
+	public static final int MEDIUM = 60;
+
+	/**
+	 * Slower compression
+	 */
+	public static final int THOROUGH = 98;
+
+	/**
+	 * Very slow compression
+	 */
+	public static final int EXHAUSTIVE = 100;
+
+	/**
+	 * Returns a string representation of the given quality level
+	 *
+	 * @param n The quality level
+	 * @return A string representation of the given quality level
+	 */
+	public static String stringFor(int n) {
+		switch (n) {
+		case FASTEST: return "FASTEST";
+		case FAST: return "FAST";
+		case MEDIUM: return "MEDIUM";
+		case THOROUGH: return "THOROUGH";
+		case EXHAUSTIVE: return "EXHAUSTIVE";
+		}
+		return "[Unknown KtxPackAstcQualityLevel]";
+	}
+
+	/**
+	 * Private constructor to prevent instantiation
+	 */
+	private KtxPackAstcQualityLevel() {
+		// Prevent instantiation
+	}
+
+
 }
diff --git a/interface/java_binding/src/main/java/org/khronos/ktx/KtxPackUASTCFlagBits.java b/interface/java_binding/src/main/java/org/khronos/ktx/KtxPackUASTCFlagBits.java
deleted file mode 100644
index 21bbf7f6b8..0000000000
--- a/interface/java_binding/src/main/java/org/khronos/ktx/KtxPackUASTCFlagBits.java
+++ /dev/null
@@ -1,22 +0,0 @@
-/*
- * Copyright (c) 2021, Shukant Pal and Contributors
- * SPDX-License-Identifier: Apache-2.0
- */
-
-package org.khronos.ktx;
-
-/** @see KtxTexture2 */
-public class KtxPackUASTCFlagBits {
-    public static final int LEVEL_FASTEST = 0;
-    public static final int LEVEL_FASTER = 1;
-    public static final int LEVEL_DEFAULT = 2;
-    public static final int LEVEL_SLOWER = 3;
-    public static final int LEVEL_VERYSLOW = 4;
-    public static final int MAX_LEVEL = LEVEL_VERYSLOW;
-    public static final int LEVEL_MASK = 0xF;
-    public static final int FAVOR_UASTC_ERROR = 8;
-    public static final int FAVOR_BC7_ERROR = 16;
-    public static final int ETC1_FASTER_HINTS = 64;
-    public static final int ETC1_FASTEST_HINTS = 128;
-    public static final int ETC1_DISABLE_FLIP_AND_INDIVIDUAL = 256;
-}
diff --git a/interface/java_binding/src/main/java/org/khronos/ktx/KtxPackUastcFlagBits.java b/interface/java_binding/src/main/java/org/khronos/ktx/KtxPackUastcFlagBits.java
new file mode 100644
index 0000000000..b0ad3f7270
--- /dev/null
+++ b/interface/java_binding/src/main/java/org/khronos/ktx/KtxPackUastcFlagBits.java
@@ -0,0 +1,139 @@
+/*
+ * Copyright (c) 2024, Khronos Group and Contributors
+ * Copyright (c) 2021, Shukant Pal and Contributors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package org.khronos.ktx;
+
+/**
+ * Flag bits that determine UASTC compression.<br>
+ * <br>
+ * These bits can be passed to {@link KtxBasisParams#setUastcFlags(int)}.<br>
+ * <br>
+ * The most important value is the level given in the least-significant
+ * 4 bits which selects a speed vs quality tradeoff.
+ */
+public class KtxPackUastcFlagBits {
+
+	/**
+	 * Fastest compression. 43.45dB.
+	 */
+    public static final int FASTEST = 0;
+
+    /**
+     * Faster compression. 46.49dB.
+     */
+    public static final int FASTER = 1;
+
+    /**
+     * Default compression. 47.47dB.
+     */
+    public static final int DEFAULT = 2;
+
+    /**
+     * Slower compression. 48.01dB.
+     */
+    public static final int SLOWER = 3;
+
+    /**
+     * Very slow compression. 48.24dB.
+     */
+    public static final int VERYSLOW = 4;
+
+    /**
+     * The maximum quality level
+     */
+    public static final int MAX_LEVEL = VERYSLOW;
+
+    /**
+     * Mask to extract the level from the other bits
+     */
+    public static final int MASK = 0xF;
+
+    /**
+     * Optimize for lowest UASTC error
+     */
+    public static final int FAVOR_UASTC_ERROR = 8;
+
+    /**
+     * Optimize for lowest BC7 error
+     */
+    public static final int FAVOR_BC7_ERROR = 16;
+
+    /**
+     * Optimize for faster transcoding to ETC1
+     */
+    public static final int ETC1_FASTER_HINTS = 64;
+
+    /**
+     * Optimize for fastest transcoding to ETC1
+     */
+    public static final int ETC1_FASTEST_HINTS = 128;
+
+    /**
+     * Not documented in BasisU code
+     */
+    public static final int ETC1_DISABLE_FLIP_AND_INDIVIDUAL = 256;
+
+
+	/**
+	 * Returns a string representation of the given flag bits
+	 *
+	 * @param n The flag bits
+	 * @return A string representation of the given flag bits
+	 */
+	public static String stringFor(int n) {
+		StringBuilder sb = new StringBuilder();
+		int level = n & MASK;
+
+		switch (level) {
+		case FASTEST: sb.append("FASTEST"); break;
+		case FASTER : sb.append("FASTER"); break;
+		case DEFAULT: sb.append("DEFAULT"); break;
+		case SLOWER: sb.append("SLOWER"); break;
+		case VERYSLOW: sb.append("VERYSLOW"); break;
+		}
+
+		if ((n & FAVOR_UASTC_ERROR) != 0) {
+			if (sb.length() != 0) {
+				sb.append("|");
+			}
+			sb.append("FAVOR_UASTC_ERROR");
+		}
+		if ((n & FAVOR_BC7_ERROR) != 0) {
+			if (sb.length() != 0) {
+				sb.append("|");
+			}
+			sb.append("FAVOR_BC7_ERROR");
+		}
+		if ((n & ETC1_FASTER_HINTS) != 0) {
+			if (sb.length() != 0) {
+				sb.append("|");
+			}
+			sb.append("ETC1_FASTER_HINTS");
+		}
+		if ((n & ETC1_FASTEST_HINTS) != 0) {
+			if (sb.length() != 0) {
+				sb.append("|");
+			}
+			sb.append("ETC1_FASTEST_HINTS");
+		}
+		if ((n & ETC1_DISABLE_FLIP_AND_INDIVIDUAL) != 0) {
+			if (sb.length() != 0) {
+				sb.append("|");
+			}
+			sb.append("ETC1_DISABLE_FLIP_AND_INDIVIDUAL");
+		}
+		return sb.toString();
+	}
+
+	/**
+	 * Private constructor to prevent instantiation
+	 */
+	private KtxPackUastcFlagBits() {
+		// Prevent instantiation
+	}
+
+
+}
diff --git a/interface/java_binding/src/main/java/org/khronos/ktx/KtxSupercmpScheme.java b/interface/java_binding/src/main/java/org/khronos/ktx/KtxSupercmpScheme.java
index fa62fd07aa..7771b85f29 100644
--- a/interface/java_binding/src/main/java/org/khronos/ktx/KtxSupercmpScheme.java
+++ b/interface/java_binding/src/main/java/org/khronos/ktx/KtxSupercmpScheme.java
@@ -1,13 +1,65 @@
 /*
  * Copyright (c) 2021, Shukant Pal and Contributors
+ * Copyright (c) 2024, Khronos Group and Contributors
  * SPDX-License-Identifier: Apache-2.0
  */
 
 package org.khronos.ktx;
 
+/**
+ * Enumerators identifying the supercompression scheme.<br>
+ * <br>
+ * These are the values that are returned by
+ * {@link KtxTexture2#getSupercompressionScheme()}.
+ */
 public class KtxSupercmpScheme {
+
+    /**
+     * No supercompression
+     */
     public static final int NONE = 0;
+
+    /**
+     * Basis LZ supercompression
+     */
     public static final int BASIS_LZ = 1;
+
+    /**
+     * ZStd supercompression
+     */
     public static final int ZSTD = 2;
+
+    /**
+     * ZLIB supercompression
+     */
     public static final int ZLIB = 3;
+
+	/**
+	 * Returns a string representation of the given supercompression scheme
+	 *
+	 * @param n The supercompression scheme
+	 * @return A string representation of the given supercompression scheme
+	 */
+	public static String stringFor(int n) {
+		switch (n) {
+		case NONE:
+			return "NONE";
+		case BASIS_LZ:
+			return "BASIS_LZ";
+		case ZSTD:
+			return "ZSTD";
+		case ZLIB:
+			return "ZLIB";
+		}
+		return "[Unknown KtxSupercmpScheme]";
+	}
+
+	/**
+	 * Private constructor to prevent instantiation
+	 */
+	private KtxSupercmpScheme() {
+		// Prevent instantiation
+	}
+
+
 }
diff --git a/interface/java_binding/src/main/java/org/khronos/ktx/KtxTexture.java b/interface/java_binding/src/main/java/org/khronos/ktx/KtxTexture.java
index 66987573cd..7f3f7fad4c 100644
--- a/interface/java_binding/src/main/java/org/khronos/ktx/KtxTexture.java
+++ b/interface/java_binding/src/main/java/org/khronos/ktx/KtxTexture.java
@@ -1,73 +1,264 @@
 /*
+ * Copyright (c) 2024, Khronos Group and Contributors
  * Copyright (c) 2021, Shukant Pal and Contributors
  * SPDX-License-Identifier: Apache-2.0
  */
 
 package org.khronos.ktx;
 
+/**
+ * Base class representing a texture.<br>
+ * <br>
+ * KTX textures should be created only by one of the provided functions and these
+ * fields should be considered read-only.<br>
+ * <br>
+ * Trying to use a KTX texture after its {@link #destroy()} method was called
+ * will result in an <code>IllegalStateException</code>.<br>
+ * <br>
+ * Unless explicitly noted, none of the parameters passed to any function
+ * may be <code>null</code>.
+ */
 public abstract class KtxTexture {
-    private final long instance;
-
-    protected KtxTexture(long instance) {
-        this.instance = instance;
-    }
-
-    /* DEBUG */
-    public boolean isDestroyed() {
-        return this.instance == 0;
-    }
-    /* DEBUG */
-
-    public native boolean isArray();
-    public native boolean isCubemap();
-    public native boolean isCompressed();
-    public native boolean getGenerateMipmaps();
-    public native int getBaseWidth();
-    public native int getBaseHeight();
-    public native int getBaseDepth();
-    public native int getNumDimensions();
-    public native int getNumLevels();
-    public native int getNumFaces();
-
-    /**
-     * Gets the image data of the KTX file (the data is copied into a Java array)
-     */
-    public native byte[] getData();
-    public native long getDataSize();
-    public native long getDataSizeUncompressed();
-    public native int getElementSize();
-    public native int getRowPitch(int level);
-    public native int getImageSize(int level);
-    public native long getImageOffset(int level, int layer, int faceSlice);
-
-    /**
-     * Destroy the KTX texture and free memory image resources
-     *
-     * NOTE: If you try to use a {@link KTXTexture} after it's destroyed, that will cause a segmentation
-     * fault (the texture pointer is set to NULL).
-     */
-    public native void destroy();
-
-    /**
-     * Set the image data - the passed data should be not modified after passing it! The bytes
-     * will be kept in memory until {@link KTXTexture#destroy} is called.
-     *
-     * @param level - The image level, should be 0 for non-mipmapped textures
-     * @param layer - The texture layer, should be 0 for non-arrays
-     * @param faceSlice - The face slice, should be 0 for non-cubemaps
-     * @param src - The image data
-     */
-    public native int setImageFromMemory(int level, int layer, int faceSlice, byte[] src);
-
-    /**
-     * Write the KTX image to the given destination file in KTX format
-     *
-     * @param dstFilename - The name of the destination file.
-     */
-    public native int writeToNamedFile(String dstFilename);
-
-    /**
-     * This **might** not work (INVALID_OPERATION for some reason)
-     */
-    public native byte[] writeToMemory();
+
+	/**
+	 * The native pointer to the <code>ktxTexture</code> instance,
+	 * converted to a 'long' value.
+	 *
+	 * This is maintained by native methods - and it may be modified,
+	 * even though it is marked as 'final' here!
+	 */
+	private final long instance;
+
+	/**
+	 * Default constructor
+	 *
+	 * @param instance The native pointer to the texture instance
+	 */
+	protected KtxTexture(long instance) {
+		this.instance = instance;
+	}
+
+	/**
+	 * Returns whether {@link #destroy()} was already called on this texture.
+	 *
+	 * @return Whether the texture is destroyed
+	 * @deprecated Only for debugging
+	 */
+	public boolean isDestroyed() {
+		return this.instance == 0;
+	}
+
+	/**
+	 * Returns <code>true</code> if the texture is an array texture.<br>
+	 * <br>
+	 * This means that a <code>GL_TEXTURE_*_ARRAY</code> target is to be used.
+	 *
+	 * @return The flag
+	 */
+	public native boolean isArray();
+
+	/**
+	 * Returns <code>true</code> if the texture is a cubemap or cubemap array
+	 *
+	 * @return The flag
+	 */
+	public native boolean isCubemap();
+
+	/**
+	 * Returns <code>true</code> if the texture's format is a block compressed format.
+	 *
+	 * @return The flag
+	 */
+	public native boolean isCompressed();
+
+	/**
+	 * Returns <code>true</code> if mipmaps should be generated for the texture.
+	 *
+	 * @return The flag
+	 */
+	public native boolean getGenerateMipmaps();
+
+	/**
+	 * Returns the width of the texture's base level.
+	 *
+	 * @return The width
+	 */
+	public native int getBaseWidth();
+
+	/**
+	 * Returns the height of the texture's base level.
+	 *
+	 * @return The height
+	 */
+	public native int getBaseHeight();
+
+	/**
+	 * Returns the depth of the texture's base level.
+	 *
+	 * @return The depth
+	 */
+	public native int getBaseDepth();
+
+	/**
+	 * Returns the number of dimensions in the texture - 1, 2 or 3.
+	 *
+	 * @return The number of dimensions
+	 */
+	public native int getNumDimensions();
+
+	/**
+	 * Returns the number of MIP levels in the texture.
+	 *
+	 * @return The number of levels
+	 */
+	public native int getNumLevels();
+
+	/**
+	 * Returns the number of faces: 6 for cube maps, 1 otherwise.
+	 *
+	 * @return The number of faces.
+	 */
+	public native int getNumFaces();
+
+	/**
+	 * Gets the image data of the KTX file.<br>
+	 * <br>
+	 * The the data is copied into a Java array.
+	 *
+	 * @return The data
+	 * @throws UnsupportedOperationException If the resulting array would
+	 * be larger than the maximum size of a Java array (i.e. more than 2GB)
+	 */
+	public native byte[] getData();
+
+	/**
+	 * Return the total size of the texture image data in bytes.
+	 *
+	 * For a {@link KtxTexture2} with {@link KtxTexture2#getSupercompressionScheme()} not
+	 * being {@link KtxSupercmpScheme#NONE}, this will return the deflated size of the data.
+	 *
+	 * @return The data size
+	 */
+	public native long getDataSize();
+
+	/**
+	 * Return the total size in bytes of the uncompressed data of a texture.<br>
+	 * <br>
+	 * For a {@link KtxTexture1}, this always returns the value of {@link #getDataSize()}.<br>
+	 * <br>
+	 * For a {@link KtxTexture2}, if the {@link KtxTexture2#getSupercompressionScheme()} is
+	 * {@link KtxSupercmpScheme#NONE} or {@link KtxSupercmpScheme#BASIS_LZ},
+	 * returns the value of {@link #getDataSize()}.<br>
+	 * <br>
+	 * Otherwise, if the supercompression scheme is {@link KtxSupercmpScheme#ZSTD} or
+	 * {@link KtxSupercmpScheme#ZLIB}, it returns the sum of the uncompressed sizes
+	 * of each mip level plus space for the level padding.<br>
+	 * <br>
+	 * With no supercompression the data size and uncompressed data size are the same.
+	 * For Basis supercompression the uncompressed size cannot be known until the data
+	 * is transcoded so the compressed size is returned.
+	 *
+	 * @return The uncompressed data size
+	 */
+	public native long getDataSizeUncompressed();
+
+	/**
+	 * Return the size in bytes of an elements of a texture's images.<br>
+	 * <br>
+	 * For uncompressed textures an element is one texel. For compressed textures it is one block.
+	 *
+	 * @return The element size
+	 */
+	public native int getElementSize();
+
+	/**
+	 * Return pitch between rows of a texture image level in bytes.<br>
+	 * <br>
+	 * For uncompressed textures the pitch is the number of bytes between rows of texels.
+	 * For compressed textures it is the number of bytes between rows of blocks. The value
+	 * is padded to <code>GL_UNPACK_ALIGNMENT</code>, if necessary. For all currently known
+	 * compressed formats padding will not be necessary.
+	 *
+	 * @param level The level
+	 * @return The row pitch in bytes
+	 */
+	public native int getRowPitch(int level);
+
+	/**
+	 * Calculate and return the size in bytes of an image at the specified mip level.<br>
+	 * <br>
+	 * For arrays, this is the size of layer, for cubemaps, the size of a face and for
+	 * 3D textures, the size of a depth slice.<br>
+	 * <br>
+	 * The size reflects the padding of each row to <code>KTX_GL_UNPACK_ALIGNMENT</code>.
+	 *
+	 * @param level The level
+	 * @return THe size in bytes
+	 */
+	public native int getImageSize(int level);
+
+	/**
+	 * Find the offset of an image within a texture's image data.<br>
+	 * <br>
+	 * As there is no such thing as a 3D cubemap we make the 3rd location parameter
+	 * do double duty. Only works for non-supercompressed textures as there is no
+	 * way to tell where an image is for a supercompressed one.<br>
+	 *
+	 * @param level The MIP level of the image
+	 * @param layer The array layer of the image
+	 * @param faceSlice The cube map face or depth slice of the image.
+	 * @return The offset, or -1 if the call internally caused a
+	 * {@link KtxErrorCode#INVALID_OPERATION}. This means that the level,
+	 * layer or faceSlice exceeded the dimensions of the texture,
+	 * or that the texture is supercompressed.
+	 */
+	public native long getImageOffset(int level, int layer, int faceSlice);
+
+	/**
+	 * Destroy the KTX texture and free memory image resources.<br>
+	 * <br>
+	 * Trying to use a {@link KtxTexture} after it was destroyed will cause a
+	 * an <code>IllegalStateException</code> to be thrown. This method is
+	 * idempotent: Calling it on an already destroyed texture will have
+	 * no effect.
+	 */
+	public native void destroy();
+
+	/**
+	 * Set image for level, layer, faceSlice from an image in memory.
+	 * <br>
+	 * Uncompressed images in memory are expected to have their rows tightly packed
+	 * as is the norm for most image file formats. KTX 2 also requires tight packing
+	 * this function does not add any padding.<br>
+	 * <br>
+	 * Level, layer, faceSlice rather than offset are specified to enable some
+	 * validation.<br>
+	 *
+	 * @param level     The image level, should be 0 for non-mipmapped textures
+	 * @param layer     The texture layer, should be 0 for non-arrays
+	 * @param faceSlice The face slice, should be 0 for non-cubemaps
+	 * @param src       The image data
+	 * @return a {@link KtxErrorCode} value
+	 */
+	public native int setImageFromMemory(int level, int layer, int faceSlice, byte[] src);
+
+	/**
+	 * Write the KTX image to the given destination file in KTX format.
+	 *
+	 * @param dstFilename The name of the destination file.
+	 * @return a {@link KtxErrorCode} value
+	 */
+	public native int writeToNamedFile(String dstFilename);
+
+	/**
+	 * Write this texture to memory.
+	 *
+	 * @return The memory containing the texture data.
+	 * @throws KtxException If the attempt to write the texture to memory caused
+	 * an error code that was not {@link KtxErrorCode#SUCCESS} in the underlying
+	 * implementation.
+	 * @throws UnsupportedOperationException If the resulting array would
+	 * be larger than the maximum size of a Java array (i.e. more than 2GB)
+	 */
+	public native byte[] writeToMemory();
 }
diff --git a/interface/java_binding/src/main/java/org/khronos/ktx/KtxTexture1.java b/interface/java_binding/src/main/java/org/khronos/ktx/KtxTexture1.java
index 572aafc223..215cab91cb 100644
--- a/interface/java_binding/src/main/java/org/khronos/ktx/KtxTexture1.java
+++ b/interface/java_binding/src/main/java/org/khronos/ktx/KtxTexture1.java
@@ -1,41 +1,111 @@
 /*
+ * Copyright (c) 2024, Khronos Group and Contributors
  * Copyright (c) 2021, Shukant Pal and Contributors
  * SPDX-License-Identifier: Apache-2.0
  */
 
 package org.khronos.ktx;
 
+/**
+ * Class representing a KTX version 1 format texture.<br>
+ * <br>
+ * KTX textures should be created only by one of the provided functions and these
+ * fields should be considered read-only.<br>
+ * <br>
+ * Trying to use a KTX texture after its {@link #destroy()} method was called
+ * will result in an <code>IllegalStateException</code>.<br>
+ * <br>
+ * Unless explicitly noted, none of the parameters passed to any function
+ * may be <code>null</code>.<br>
+ */
 public class KtxTexture1 extends KtxTexture {
-    protected KtxTexture1(long instance) {
-        super(instance);
-    }
-
-    public native int getGlFormat();
-    public native int getGlInternalformat();
-    public native int getGlBaseInternalformat();
-    public native int getGlType();
-
-    /**
-     * Create a fresh {@link KTXTexture1}
-     *
-     * @param createInfo - Paramaters for the texture
-     * @param storageAllocation - Pass {@link KTXCreateStorage.ALLOC} if you will write image data.
-     */
-    public static native KtxTexture1 create(KtxTextureCreateInfo info,
-                                            int storageAllocation);
-
-    /**
-     * Create a {@link KTXTexture1} from a file.
-     *
-     * @param filename - The name of the file to read.
-     * @param createFlags - Pass {@link KTXTextureCreateFlagBits.LOAD_IMAGE_DATA_BIT} if you
-     *                   want to read image data! Otherwise, {@link KTXTexture.getData()} will
-     *                    return null.
-     */
-    public static native KtxTexture1 createFromNamedFile(String filename,
-                                                         int createFlags);
-
-    public static KtxTexture1 createFromNamedFile(String filename) {
-        return createFromNamedFile(filename, KtxTextureCreateFlagBits.LOAD_IMAGE_DATA_BIT);
-    }
+
+	/**
+	 * Creates a new instance.<br>
+	 * <br>
+	 * This is only called from native methods.
+	 *
+	 * @param instance The pointer to the native instance,
+	 * converted to a 'long' value.
+	 */
+	protected KtxTexture1(long instance) {
+		super(instance);
+	}
+
+	/**
+	 * Returns the format of the texture data.<br>
+	 * <br>
+	 * This will be a constant like <code>GL_RGB</code>.
+	 *
+	 * @return The format of the texture data
+	 */
+	public native int getGlFormat();
+
+	/**
+	 * Returns the internal format of the texture data.<br>
+	 * <br>
+	 * This will be a constant like <code>GL_RGB8</code>.
+	 *
+	 * @return The internal format of the texture data
+	 */
+	public native int getGlInternalformat();
+
+	/**
+	 * Returns the base format of the texture data.<br>
+	 * <br>
+	 * This will be a constant like <code>GL_RGB</code>.
+	 *
+	 * @return The base internal format of the texture data
+	 */
+	public native int getGlBaseInternalformat();
+
+	/**
+	 * Returns the type of the texture data.<br>
+	 * <br>
+	 * This will be a constant like <code>GL_UNSIGNED_BYTE</code>.
+	 *
+	 * @return The type of the texture data
+	 */
+	public native int getGlType();
+
+	/**
+	 * Create a fresh {@link KtxTexture1}
+	 *
+	 * @param info The {@link KtxTextureCreateInfo} parameters for the texture
+	 * @param storageAllocation The storage allocation. Pass {@link KtxTextureCreateStorage#ALLOC_STORAGE} if you will write image data.
+	 * @return The {@link KtxTexture1}
+	 * @throws KtxException If the input parameters have been invalid and caused
+	 * an error code that was not {@link KtxErrorCode#SUCCESS} in the underlying
+	 * implementation.
+	 */
+	public static native KtxTexture1 create(KtxTextureCreateInfo info,
+			int storageAllocation);
+
+	/**
+	 * Create a {@link KtxTexture1} from a file.
+	 *
+	 * @param filename The name of the file to read.
+	 * @param createFlags The creation flag bits. Pass {@link KtxTextureCreateFlagBits#LOAD_IMAGE_DATA_BIT} if you
+	 *                   want to read image data! Otherwise, {@link KtxTexture#getData()} will
+	 *                    return null.
+	 * @return The {@link KtxTexture1}
+	 * @throws KtxException If the input file was invalid and caused
+	 * an error code that was not {@link KtxErrorCode#SUCCESS} in the underlying
+	 * implementation.
+	 */
+	public static native KtxTexture1 createFromNamedFile(String filename,
+			int createFlags);
+
+	/**
+	 * Create a {@link KtxTexture1} from a file.
+	 *
+	 * @param filename The name of the file to read.
+	 * @return The {@link KtxTexture1}
+	 * @throws KtxException If the input file was invalid and caused
+	 * an error code that was not {@link KtxErrorCode#SUCCESS} in the underlying
+	 * implementation.
+	 */
+	public static KtxTexture1 createFromNamedFile(String filename) {
+		return createFromNamedFile(filename, KtxTextureCreateFlagBits.LOAD_IMAGE_DATA_BIT);
+	}
 }
diff --git a/interface/java_binding/src/main/java/org/khronos/ktx/KtxTexture2.java b/interface/java_binding/src/main/java/org/khronos/ktx/KtxTexture2.java
index a7aa577514..ae06b1fb4e 100644
--- a/interface/java_binding/src/main/java/org/khronos/ktx/KtxTexture2.java
+++ b/interface/java_binding/src/main/java/org/khronos/ktx/KtxTexture2.java
@@ -1,74 +1,335 @@
 /*
+ * Copyright (c) 2024, Khronos Group and Contributors
  * Copyright (c) 2021, Shukant Pal and Contributors
  * SPDX-License-Identifier: Apache-2.0
  */
 
 package org.khronos.ktx;
 
+import java.nio.ByteBuffer;
+
+/**
+ * Class representing a KTX version 2 format texture.<br>
+ * <br>
+ * KTX textures should be created only by one of the provided functions and these
+ * fields should be considered read-only.<br>
+ * <br>
+ * Trying to use a KTX texture after its {@link #destroy()} method was called
+ * will result in an <code>IllegalStateException</code>.<br>
+ * <br>
+ * Unless explicitly noted, none of the parameters passed to any function
+ * may be <code>null</code>.<br>
+ */
 public class KtxTexture2 extends KtxTexture {
-    protected KtxTexture2(long instance) {
-        super(instance);
-    }
-
-    public native int getOETF();
-    public native boolean getPremultipliedAlpha();
-    public native boolean needsTranscoding();
-    public native int getVkFormat();
-    public native int getSupercompressionScheme();
-
-    public native int compressAstcEx(KtxAstcParams params);
-    public native int compressAstc(int quality);
-    public native int compressBasisEx(KtxBasisParams params);
-    public native int compressBasis(int quality);
-    public native int transcodeBasis(int outputFormat, int transcodeFlags);
-
-    /**
-     * Create a fresh {@link KTXTexture2}
-     *
-     * @param createInfo - Paramaters for the texture
-     * @param storageAllocation - Pass {@link KTXCreateStorage.ALLOC} if you will write image data.
-     */
-    public static native KtxTexture2 create(KtxTextureCreateInfo createInfo,
-                                            int storageAllocation);
-
-    /**
-     * Create a {@link KTXTexture2} from a file.
-     *
-     * @param filename - The name of the file to read.
-     * @param createFlags - Pass {@link KTXTextureCreateFlagBits.LOAD_IMAGE_DATA_BIT} if you
-     *                   want to read image data! Otherwise, {@link KTXTexture.getData()} will
-     *                    return null.
-     */
-    public static native KtxTexture2 createFromNamedFile(String filename,
-                                                         int createFlags);
-
-    public static KtxTexture2 createFromNamedFile(String filename) {
-        return createFromNamedFile(filename, KtxTextureCreateFlagBits.LOAD_IMAGE_DATA_BIT);
-    }
-
-    /**
-     * Deflate the data in a {@link KtxTexture2} object using Zstandard.
-     *
-     * The texture's levelIndex, dataSize, DFD, data pointer, and supercompressionScheme will
-     * all be updated after successful deflation to reflect the deflated data.
-     *
-     * @param level Set speed vs compression ratio trade-off. Values
-     * between 1 and 22 are accepted. The lower the level the faster. Values
-     * above 20 should be used with caution as they require more memory.
-     * @return A {@link KtxErrorCode} value
-     */
-    public native int deflateZstd(int level);
-
-    /**
-     * Deflate the data in a {@link KtxTexture2} object using miniz (ZLIB)
-     *
-     * The texture's levelIndex, dataSize, DFD, data pointer, and supercompressionScheme will
-     * all be updated after successful deflation to reflect the deflated data.
-     *
-     * @param level Set speed vs compression ratio trade-off. Values
-     * between 1 and 9 are accepted. The lower the level the faster.
-     * @return A {@link KtxErrorCode} value
-     */
-    public native int deflateZLIB(int level);
+	/**
+	 * Creates a new instance.<br>
+	 * <br>
+	 * This is only called from native methods.
+	 *
+	 * @param instance The pointer to the native instance,
+	 * converted to a 'long' value.
+	 */
+	protected KtxTexture2(long instance) {
+		super(instance);
+	}
+
+	/**
+	 * Returns the the opto-electrical transfer function of the images.<br>
+	 * <br>
+	 * This is one of the constants in {@link KhrDfTransfer}.
+	 *
+	 * @return The transfer function.
+	 */
+	public native int getOETF();
+
+	/**
+	 * Returns whether the RGB components have been premultiplied by the alpha component.
+	 *
+	 * @return The premultiplied flag
+	 */
+	public native boolean getPremultipliedAlpha();
+
+	/**
+	 * Returns whether the images are in a transcodable format.
+	 *
+	 * @return Whether the images are transcodable
+	 */
+	public native boolean needsTranscoding();
+
+	/**
+	 * Return the {@link VkFormat} of this texture
+	 *
+	 * @return The {@link VkFormat}
+	 */
+	public native int getVkFormat();
+
+	/**
+	 * Returns the supercompression scheme that has been applied to
+	 * this texture.<br>
+	 * <br>
+	 * This is a constant from the {@link KtxSupercmpScheme} class.
+	 *
+	 * @return The supercompression scheme.
+	 */
+	public native int getSupercompressionScheme();
+
+	/**
+	 * Encode and compress a ktx texture with uncompressed images to astc.<br>
+	 * <br>
+	 * The images are encoded to ASTC block-compressed format. The encoded
+	 * images replace the original images and the texture's fields including
+	 * the DFD are modified to reflect the new state.<br>
+	 * <br>
+	 * Such textures can be directly uploaded to a GPU via a graphics API.
+	 *
+	 * @param params The {@link KtxAstcParams}
+	 * @return A {@link KtxErrorCode} constant:<br>
+	 * {@link KtxErrorCode#SUCCESS} on success<br>
+	 * {@link KtxErrorCode#INVALID_OPERATION} The texture's images are supercompressed.<br>
+	 * {@link KtxErrorCode#INVALID_OPERATION} The texture's images are in a block compressed format.<br>
+	 * {@link KtxErrorCode#INVALID_OPERATION} The texture image's format is a packed format (e.g. RGB565).<br>
+	 * {@link KtxErrorCode#INVALID_OPERATION} The texture image format's component size is not 8-bits.<br>
+	 * {@link KtxErrorCode#INVALID_OPERATION} The texture's images are 1D. Only 2D images can be supercompressed.<br>
+	 * {@link KtxErrorCode#INVALID_OPERATION} ASTC compressor failed to compress image for any reason.<br>
+	 * {@link KtxErrorCode#OUT_OF_MEMORY} Not enough memory to carry out compression.
+	 */
+	public native int compressAstcEx(KtxAstcParams params);
+
+	/**
+	 * Encode and compress a ktx texture with uncompressed images to astc.<br>
+	 * <br>
+	 * The images are either encoded to ASTC block-compressed format. The encoded images
+	 * replace the original images and the texture's fields including the DFD are
+	 * modified to reflect the new state.<br>
+	 * <br>
+	 * Such textures can be directly uploaded to a GPU via a graphics API.
+	 *
+	 * @param quality The compression quality, a value from 0 - 100.
+	 * Higher=higher quality/slower speed. Lower=lower quality/faster speed.
+	 * Negative values for quality are considered to be greater than 100.
+	 * @return A {@link KtxErrorCode} constant:<br>
+	 * {@link KtxErrorCode#SUCCESS} on success<br>
+	 * {@link KtxErrorCode#INVALID_OPERATION} The texture is already supercompressed.<br>
+	 * {@link KtxErrorCode#INVALID_OPERATION} The texture's image are in a block compressed format.<br>
+	 * {@link KtxErrorCode#INVALID_OPERATION} The texture image's format is a packed format (e.g. RGB565).<br>
+	 * {@link KtxErrorCode#INVALID_OPERATION} The texture image format's component size is not 8-bits.<br>
+	 * {@link KtxErrorCode#INVALID_OPERATION} The texture's images are 1D. Only 2D images can be supercompressed.<br>
+	 * {@link KtxErrorCode#OUT_OF_MEMORY} Not enough memory to carry out supercompression.<br>
+	 */
+	public native int compressAstc(int quality);
+
+	/**
+	 * Encode and possibly Supercompress a KTX2 texture with uncompressed images.<br>
+	 * <br>
+	 * The images are either encoded to ETC1S block-compressed format and supercompressed
+	 * with Basis LZ or they are encoded to UASTC block-compressed format. UASTC format
+	 * is selected by setting the {@link KtxBasisParams#setUastc(boolean)} to <code>true</code>.
+	 * The encoded images replace the original images and the texture's fields including the
+	 * DFD are modified to reflect the new state.<br>
+	 * <br>
+	 * Such textures must be transcoded to a desired target block compressed format before
+	 * they can be uploaded to a GPU via a graphics API.
+	 *
+	 * @param params The {@link KtxBasisParams}
+	 * @return A {@link KtxErrorCode} constant:<br>
+	 * {@link KtxErrorCode#SUCCESS} on success<br>
+	 * {@link KtxErrorCode#INVALID_OPERATION} The texture's images are supercompressed.<br>
+	 * {@link KtxErrorCode#INVALID_OPERATION} The texture's images are in a block compressed format.<br>
+	 * {@link KtxErrorCode#INVALID_OPERATION} The texture image's format is a packed format (e.g. RGB565).<br>
+	 * {@link KtxErrorCode#INVALID_OPERATION} The texture image format's component size is not 8-bits.<br>
+	 * {@link KtxErrorCode#INVALID_OPERATION} normalMode is specified but the texture has only one component.<br>
+	 * {@link KtxErrorCode#INVALID_OPERATION} Both preSwizzle and and inputSwizzle are specified in params.<br>
+	 * {@link KtxErrorCode#OUT_OF_MEMORY} Not enough memory to carry out compression.<br>
+	 */
+	public native int compressBasisEx(KtxBasisParams params);
+
+	/**
+	 * Supercompress a KTX2 texture with uncompressed images.<br>
+	 * <br>
+	 * The images are encoded to ETC1S block-compressed format and supercompressed
+	 * with Basis Universal. The encoded images replace the original images and
+	 * the texture's fields including the DFD are modified to reflect the new state.<br>
+	 * <br>
+	 * Such textures must be transcoded to a desired target block compressed
+	 * format before they can be uploaded to a GPU via a graphics API.<br>
+	 * <br>
+	 * @param quality Compression quality, a value from 1 - 255. Default is 128 which
+	 * is selected if quality is 0. Lower=better compression/lower quality/faster.
+	 * Higher=less compression/higher quality/slower.
+	 * @return A {@link KtxErrorCode} constant:<br>
+	 * {@link KtxErrorCode#SUCCESS} on success<br>
+	 * {@link KtxErrorCode#INVALID_OPERATION} The texture is already supercompressed.<br>
+	 * {@link KtxErrorCode#INVALID_OPERATION} The texture's image are in a block compressed format.<br>
+	 * {@link KtxErrorCode#OUT_OF_MEMORY} Not enough memory to carry out supercompression.
+	 */
+	public native int compressBasis(int quality);
+
+	/**
+	 * Transcode a KTX2 texture with BasisLZ/ETC1S or UASTC images.<br>
+	 * <br>
+	 * If the texture contains BasisLZ supercompressed images, Inflates them from
+	 * back to ETC1S then transcodes them to the specified block-compressed format.
+	 * If the texture contains UASTC images, inflates them, if they have been
+	 * supercompressed with zstd, then transcodes then to the specified format, The
+	 * transcoded images replace the original images and the texture's fields
+	 * including the DFD are modified to reflect the new format.<br>
+	 * <br>
+	 * These types of textures must be transcoded to a desired target
+	 * block-compressed format before they can be uploaded to a GPU via a graphics
+	 * API.<br>
+	 * <br>
+	 * The following block compressed transcode targets are available: <br>
+	 * {@link KtxTranscodeFormat#ETC1_RGB}<br>
+	 * {@link KtxTranscodeFormat#ETC2_RGBA}<br>
+	 * {@link KtxTranscodeFormat#BC1_RGB}<br>
+	 * {@link KtxTranscodeFormat#BC3_RGBA}<br>
+	 * {@link KtxTranscodeFormat#BC4_R}<br>
+	 * {@link KtxTranscodeFormat#BC5_RG}<br>
+	 * {@link KtxTranscodeFormat#BC7_RGBA}<br>
+	 * {@link KtxTranscodeFormat#PVRTC1_4_RGB}<br>
+	 * {@link KtxTranscodeFormat#PVRTC1_4_RGBA}<br>
+	 * {@link KtxTranscodeFormat#PVRTC2_4_RGB}<br>
+	 * {@link KtxTranscodeFormat#PVRTC2_4_RGBA}<br>
+	 * {@link KtxTranscodeFormat#ASTC_4x4_RGBA}<br>
+	 * {@link KtxTranscodeFormat#ETC2_EAC_R11}<br>
+	 * {@link KtxTranscodeFormat#ETC2_EAC_RG11}<br>
+	 * {@link KtxTranscodeFormat#ETC}<br>
+	 * {@link KtxTranscodeFormat#BC1_OR_3}<br>
+	 * <br>
+	 * <code>ETC</code> automatically selects between
+	 * <code>ETC1_RGB</code> and <code>ETC2_RGBA</code> according to
+	 * whether an alpha channel is available. <code>BC1_OR_3</code> does
+	 * likewise between <code>BC1_RGB</code> and
+	 * <code>BC3_RGBA</code>. Note that if
+	 * <code>PVRTC1_4_RGBA</code> or <code>PVRTC2_4_RGBA</code> is
+	 * specified and there is no alpha channel <code>PVRTC1_4_RGB</code> or
+	 * <code>PVRTC2_4_RGB</code> respectively will be selected. <br>
+	 * Transcoding to ATC and FXT1 formats is not supported by libktx as there are no
+	 * equivalent Vulkan formats.<br>
+	 * <br>
+	 * The following uncompressed transcode targets are also available: <br>
+	 * {@link KtxTranscodeFormat#RGBA32}<br>
+	 * {@link KtxTranscodeFormat#RGB565}<br>
+	 * {@link KtxTranscodeFormat#BGR565}<br>
+	 * {@link KtxTranscodeFormat#RGBA4444}<br>
+	 * <br>
+	 * The following transcodeFlags are available:<br>
+	 * <br>
+	 * {@link KtxTranscodeFlagBits#PVRTC_DECODE_TO_NEXT_POW2}<br>
+	 * {@link KtxTranscodeFlagBits#TRANSCODE_ALPHA_DATA_TO_OPAQUE_FORMATS}<br>
+	 * {@link KtxTranscodeFlagBits#HIGH_QUALITY}<br>
+	 *
+	 * @param outputFormat   A value from the {@link KtxTranscodeFormat} specifying
+	 *                       the target format.
+	 * @param transcodeFlags A bitfield of flags from {@link KtxTranscodeFlagBits}
+	 *                       modifying the transcode
+	 * @return {@link KtxErrorCode#SUCCESS} on success, or a code indicating the error:<br>
+	 * {@link KtxErrorCode#FILE_DATA_ERROR} Supercompression global data
+	 * is corrupted.<br>
+	 * {@link KtxErrorCode#INVALID_OPERATION} The
+	 * texture's format is not transcodable (not ETC1S/BasisLZ or UASTC).<br>
+	 * {@link KtxErrorCode#INVALID_OPERATION} Supercompression global
+	 * data is missing, i.e., the texture object is invalid.<br>
+	 * {@link KtxErrorCode#INVALID_OPERATION} Image data is missing,
+	 * i.e., the texture object is invalid.<br>
+	 * {@link KtxErrorCode#INVALID_OPERATION} outputFormat is PVRTC1 but the texture
+	 * does does not have power-of-two dimensions.<br>
+	 * {@link KtxErrorCode#INVALID_VALUE} outputFormat is invalid.<br>
+	 * {@link KtxErrorCode#TRANSCODE_FAILED} Something went wrong during transcoding.<br>
+	 * {@link KtxErrorCode#UNSUPPORTED_FEATURE} PVRTC_DECODE_TO_NEXT_POW2 was
+	 * requested or the specified transcode target has not been included in the library
+	 * being used.<br>
+	 * {@link KtxErrorCode#OUT_OF_MEMORY} Not enough memory to carry out transcoding.<br>
+	 */
+	public native int transcodeBasis(int outputFormat, int transcodeFlags);
+
+	/**
+	 * Create a fresh {@link KtxTexture2}
+	 *
+	 * @param createInfo The {@link KtxTextureCreateInfo} parameters for the texture
+	 * @param storageAllocation The storage allocation. Pass {@link KtxTextureCreateStorage#ALLOC_STORAGE} if you will write image data.
+	 * @return The {@link KtxTexture2}
+	 * @throws KtxException If the input parameters have been invalid and caused
+	 * an error code that was not {@link KtxErrorCode#SUCCESS} in the underlying
+	 * implementation.
+	 */
+	public static native KtxTexture2 create(KtxTextureCreateInfo createInfo,
+			int storageAllocation);
+
+	/**
+	 * Create a {@link KtxTexture2} from a file.
+	 *
+	 * @param filename The name of the file to read.
+	 * @param createFlags Pass {@link KtxTextureCreateFlagBits#LOAD_IMAGE_DATA_BIT} if you
+	 *                   want to read image data! Otherwise, {@link KtxTexture#getData()} will
+	 *                    return null.
+	 * @return The {@link KtxTexture2}
+	 * @throws KtxException If the input data was invalid and caused
+	 * an error code that was not {@link KtxErrorCode#SUCCESS} in the underlying
+	 * implementation.
+	 */
+	public static native KtxTexture2 createFromNamedFile(String filename,
+			int createFlags);
+
+	/**
+	 * Create a {@link KtxTexture2} from a file.
+	 *
+	 * @param filename The name of the file to read.
+	 * @return The {@link KtxTexture2}
+	 * @throws KtxException If the input data was invalid and caused
+	 * an error code that was not {@link KtxErrorCode#SUCCESS} in the underlying
+	 * implementation.
+	 */
+	public static KtxTexture2 createFromNamedFile(String filename) {
+		return createFromNamedFile(filename, KtxTextureCreateFlagBits.LOAD_IMAGE_DATA_BIT);
+	}
+
+	/**
+	 * Create a {@link KtxTexture2} from KTX-formatted data in memory.<br>
+	 * <br>
+	 * The create flag {@link KtxTextureCreateFlagBits#LOAD_IMAGE_DATA_BIT}
+	 * should not be set if the ktxTexture is ultimately to be uploaded to
+	 * OpenGL or Vulkan. This will minimize memory usage by allowing, for
+	 * example, loading the images directly from the source into a Vulkan
+	 * staging buffer.<br>
+	 * <br>
+	 * The create flag {@link KtxTextureCreateFlagBits#RAW_KVDATA_BIT} should
+	 * not be used. It is provided solely to enable implementation of the
+	 * libktx v1 API on top of ktxTexture.<br>
+	 * <br>
+	 * @param byteBuffer The buffer containing the serialized KTX data.
+	 * @param createFlags bitmask requesting specific actions during creation.
+	 * @return The {@link KtxTexture2}
+	 * @throws KtxException If the input data was invalid and caused
+	 * an error code that was not {@link KtxErrorCode#SUCCESS} in the underlying
+	 * implementation.
+	 */
+	public static native KtxTexture2 createFromMemory(
+			ByteBuffer byteBuffer, int createFlags);
+
+	/**
+	 * Deflate the data in a {@link KtxTexture2} object using Zstandard.<br>
+	 * <br>
+	 * The texture's levelIndex, dataSize, DFD, data pointer, and supercompressionScheme will
+	 * all be updated after successful deflation to reflect the deflated data.<br>
+	 *
+	 * @param level Set speed vs compression ratio trade-off. Values
+	 * between 1 and 22 are accepted. The lower the level the faster. Values
+	 * above 20 should be used with caution as they require more memory.
+	 * @return A {@link KtxErrorCode} value
+	 */
+	public native int deflateZstd(int level);
+
+	/**
+	 * Deflate the data in a {@link KtxTexture2} object using miniz (ZLIB).<br>
+	 * <br>
+	 * The texture's levelIndex, dataSize, DFD, data pointer, and supercompressionScheme will
+	 * all be updated after successful deflation to reflect the deflated data.<br>
+	 *
+	 * @param level Set speed vs compression ratio trade-off. Values
+	 * between 1 and 9 are accepted. The lower the level the faster.
+	 * @return A {@link KtxErrorCode} value
+	 */
+	public native int deflateZLIB(int level);
 
 }
diff --git a/interface/java_binding/src/main/java/org/khronos/ktx/KtxTextureCreateFlagBits.java b/interface/java_binding/src/main/java/org/khronos/ktx/KtxTextureCreateFlagBits.java
index 71e19ac82f..17c87c94e0 100644
--- a/interface/java_binding/src/main/java/org/khronos/ktx/KtxTextureCreateFlagBits.java
+++ b/interface/java_binding/src/main/java/org/khronos/ktx/KtxTextureCreateFlagBits.java
@@ -1,13 +1,85 @@
 /*
+ * Copyright (c) 2024, Khronos Group and Contributors
  * Copyright (c) 2021, Shukant Pal and Contributors
  * SPDX-License-Identifier: Apache-2.0
  */
 
 package org.khronos.ktx;
 
+/**
+ * Flags for requesting services during creation.<br>
+ * <br>
+ * These are passed to the <code>createFrom...</code> functions:<br>
+ * {@link KtxTexture2#createFromNamedFile(String, int)}<br>
+ * {@link KtxTexture2#createFromMemory(java.nio.ByteBuffer, int)}<br>
+ * {@link KtxTexture1#createFromNamedFile(String, int)}<br>
+ *
+ */
 public class KtxTextureCreateFlagBits {
-    public static final int NO_FLAGS = 0x00;
-    public static final int LOAD_IMAGE_DATA_BIT = 0x01;
-    public static final int RAW_KVDATA_BIT = 0x02;
-    public static final int SKIP_KVDATA_BIT = 0x04;
+
+	/**
+	 * No flags set
+	 */
+	public static final int NO_FLAGS = 0x00;
+
+	/**
+	 * Load the images from the KTX source
+	 */
+	public static final int LOAD_IMAGE_DATA_BIT = 0x01;
+
+	/**
+	 * Load the raw key-value data instead of creating a ktxHashList from it.
+	 */
+	public static final int RAW_KVDATA_BIT = 0x02;
+
+	/**
+	 * Skip any key-value data. This overrides the RAW_KVDATA_BIT.
+	 */
+	public static final int SKIP_KVDATA_BIT = 0x04;
+
+	/**
+	 * Returns a string representation of the given flag bits
+	 *
+	 * @param n The flag bits
+	 * @return A string representation of the given flag bits
+	 */
+	public static String stringFor(int n) {
+		if (n == 0)
+		{
+			return "NO_FLAGS";
+		}
+		StringBuilder sb = new StringBuilder();
+		if ((n & LOAD_IMAGE_DATA_BIT) != 0) {
+			if (sb.length() != 0) {
+				sb.append("|");
+			}
+			sb.append("LOAD_IMAGE_DATA_BIT");
+		}
+		if ((n & RAW_KVDATA_BIT) != 0) {
+			if (sb.length() != 0) {
+				sb.append("|");
+			}
+			sb.append("RAW_KVDATA_BIT");
+		}
+		if ((n & SKIP_KVDATA_BIT) != 0) {
+			if (sb.length() != 0) {
+				sb.append("|");
+			}
+			sb.append("SKIP_KVDATA_BIT");
+		}
+		if (sb.length() == 0)
+		{
+			return "[Unknown KtxTextureCreateFlagBits]";
+		}
+		return sb.toString();
+	}
+
+	/**
+	 * Private constructor to prevent instantiation
+	 */
+	private KtxTextureCreateFlagBits() {
+		// Prevent instantiation
+	}
+
+
 }
diff --git a/interface/java_binding/src/main/java/org/khronos/ktx/KtxTextureCreateInfo.java b/interface/java_binding/src/main/java/org/khronos/ktx/KtxTextureCreateInfo.java
index 689afbaaaf..358d730e36 100644
--- a/interface/java_binding/src/main/java/org/khronos/ktx/KtxTextureCreateInfo.java
+++ b/interface/java_binding/src/main/java/org/khronos/ktx/KtxTextureCreateInfo.java
@@ -1,108 +1,303 @@
 /*
+ * Copyright (c) 2024, Khronos Group and Contributors
  * Copyright (c) 2021, Shukant Pal and Contributors
  * SPDX-License-Identifier: Apache-2.0
  */
 
 package org.khronos.ktx;
 
+/**
+ * Structure for passing texture information to {@link KtxTexture1#create(KtxTextureCreateInfo, int)}
+ * and {@link KtxTexture2#create(KtxTextureCreateInfo, int)}.
+ */
 public class KtxTextureCreateInfo {
-    private int glInternalformat;
-    private int baseWidth = 0;
-    private int baseHeight = 0;
-    private int baseDepth = 1;
-    private int numDimensions = 2;
-    private int numLevels = 1;
-    private int numLayers = 1;
-    private int numFaces = 1;
-    private boolean isArray = false;
-    private boolean generateMipmaps = false;
-    private int vkFormat;
-
-    public int getGlInternalformat() {
-        return this.glInternalformat;
-    }
-
-    public void setGlInternalformat(int glInternalformat) {
-        this.glInternalformat = glInternalformat;
-    }
-
-    public int getBaseWidth() {
-        return baseWidth;
-    }
-
-    public void setBaseWidth(int baseWidth) {
-        this.baseWidth = baseWidth;
-    }
-
-    public int getBaseHeight() {
-        return baseHeight;
-    }
-
-    public void setBaseHeight(int baseHeight) {
-        this.baseHeight = baseHeight;
-    }
-
-    public int getBaseDepth() {
-        return baseDepth;
-    }
-
-    public void setBaseDepth(int baseDepth) {
-        this.baseDepth = baseDepth;
-    }
-
-    public int getNumDimensions() {
-        return numDimensions;
-    }
-
-    public void setNumDimensions(int numDimensions) {
-        this.numDimensions = numDimensions;
-    }
-
-    public int getNumLevels() {
-        return numLevels;
-    }
-
-    public void setNumLevels(int numLevels) {
-        this.numLevels = numLevels;
-    }
-
-    public int getNumLayers() {
-        return numLayers;
-    }
-
-    public void setNumLayers(int numLayers) {
-        this.numLayers = numLayers;
-    }
-
-    public int getNumFaces() {
-        return numFaces;
-    }
-
-    public void setNumFaces(int numFaces) {
-        this.numFaces = numFaces;
-    }
-
-    public boolean isArray() {
-        return isArray;
-    }
-
-    public void setArray(boolean array) {
-        isArray = array;
-    }
-
-    public boolean isGenerateMipmaps() {
-        return generateMipmaps;
-    }
-
-    public void setGenerateMipmaps(boolean generateMipmaps) {
-        this.generateMipmaps = generateMipmaps;
-    }
-
-    public int getVkFormat() {
-        return this.vkFormat;
-    }
-
-    public void setVkFormat(int vkFormat) {
-        this.vkFormat = vkFormat;
-    }
+
+	/**
+	 * The internal format for the texture
+	 */
+	private int glInternalformat;
+
+	/**
+	 * Width of the base level of the texture.
+	 */
+	private int baseWidth = 0;
+
+	/**
+	 * Height of the base level of the texture.
+	 */
+	private int baseHeight = 0;
+
+	/**
+	 * Depth of the base level of the texture.
+	 */
+	private int baseDepth = 1;
+
+	/**
+	 * Number of dimensions in the texture.
+	 */
+	private int numDimensions = 2;
+
+	/**
+	 * Number of MIP levels in the texture.
+	 */
+	private int numLevels = 1;
+
+	/**
+	 * Number of array layers in the texture.
+	 */
+	private int numLayers = 1;
+
+	/**
+	 * The number of faces.
+	 */
+	private int numFaces = 1;
+
+	/**
+	 * Whether the texture is an array texture
+	 */
+	private boolean isArray = false;
+
+	/**
+	 * Whether mipmaps should be generated
+	 */
+	private boolean generateMipmaps = false;
+
+	/**
+	 * VkFormat for the texture
+	 */
+	private int vkFormat;
+
+	/**
+	 * Default constructor
+	 */
+	public KtxTextureCreateInfo() {
+		// Nothing to do here
+	}
+
+	/**
+	 * Returns the internal format for the texture
+	 *
+	 * See {@link #setGlInternalformat(int)}
+	 *
+	 * @return The internal format
+	 */
+	public int getGlInternalformat() {
+		return this.glInternalformat;
+	}
+
+	/**
+	 * Set the internal format for the texture.<br>
+	 * <br>
+	 * This is one of the constants from {@link KtxInternalformat}, for example
+	 * {@link KtxInternalformat#GL_RGB8}. Ignored when creating a {@link KtxTexture2}.
+	 *
+	 * @param glInternalformat The internal format
+	 */
+	public void setGlInternalformat(int glInternalformat) {
+		this.glInternalformat = glInternalformat;
+	}
+
+	/**
+	 * Returns the width of the base level of the texture.
+	 *
+	 * @return The base width
+	 */
+	public int getBaseWidth() {
+		return baseWidth;
+	}
+
+	/**
+	 * Set the width of the base level of the texture.
+	 *
+	 * @param baseWidth The base width
+	 */
+	public void setBaseWidth(int baseWidth) {
+		this.baseWidth = baseWidth;
+	}
+
+	/**
+	 * Returns the height of the base level of the texture.
+	 *
+	 * @return The base height
+	 */
+	public int getBaseHeight() {
+		return baseHeight;
+	}
+
+	/**
+	 * Set the height of the base level of the texture.
+	 *
+	 * @param baseHeight The base height
+	 */
+	public void setBaseHeight(int baseHeight) {
+		this.baseHeight = baseHeight;
+	}
+
+	/**
+	 * Returns the depth of the base level of the texture.
+	 *
+	 * @return The base depth
+	 */
+	public int getBaseDepth() {
+		return baseDepth;
+	}
+
+	/**
+	 * Set the depth of the base level of the texture.
+	 *
+	 * @param baseDepth The base depth
+	 */
+	public void setBaseDepth(int baseDepth) {
+		this.baseDepth = baseDepth;
+	}
+
+	/**
+	 * Returns the number of dimensions in the texture.
+	 *
+	 * See {@link #setNumDimensions(int)}
+	 *
+	 * @return The number of dimensions
+	 */
+	public int getNumDimensions() {
+		return numDimensions;
+	}
+
+	/**
+	 * Set the number of dimensions in the texture.<br>
+	 * <br>
+	 * This may be 1, 2, or 3.
+	 *
+	 * @param numDimensions The number of dimensions
+	 */
+	public void setNumDimensions(int numDimensions) {
+		this.numDimensions = numDimensions;
+	}
+
+	/**
+	 * Returns the number of MIP levels in the texture.
+	 *
+	 * See {@link #setNumLevels(int)}
+	 *
+	 * @return The number of levels
+	 */
+	public int getNumLevels() {
+		return numLevels;
+	}
+
+	/**
+	 * Set the number of MIP levels in the texture.<br>
+	 * <br>
+	 * This should be 1 if {@link #isGenerateMipmaps()} is <code>true</code>.
+	 *
+	 * @param numLevels The number of levels
+	 */
+	public void setNumLevels(int numLevels) {
+		this.numLevels = numLevels;
+	}
+
+	/**
+	 * Returns the number of array layers in the texture.
+	 *
+	 * @return The number of layers
+	 */
+	public int getNumLayers() {
+		return numLayers;
+	}
+
+	/**
+	 * Set the number of array layers in the texture.
+	 *
+	 * @param numLayers The number of layers
+	 */
+	public void setNumLayers(int numLayers) {
+		this.numLayers = numLayers;
+	}
+
+	/**
+	 * Returns the number of faces.
+	 *
+	 * See {@link #setNumFaces(int)}
+	 *
+	 * @return The number of faces
+	 */
+	public int getNumFaces() {
+		return numFaces;
+	}
+
+	/**
+	 * Set the number of faces.<br>
+	 * <br>
+	 * This should be 6 for cube maps, 1 otherwise.
+	 *
+	 * @param numFaces The number of faces
+	 */
+	public void setNumFaces(int numFaces) {
+		this.numFaces = numFaces;
+	}
+
+	/**
+	 * Returns whether the texture is an array texture.
+	 *
+	 * See {@link #setArray(boolean)}
+	 *
+	 * @return Whether the texture is an array texture
+	 */
+	public boolean isArray() {
+		return isArray;
+	}
+
+	/**
+	 * Set whether the texture is an array texture.
+	 *
+	 * This means that OpenGL will use a <code>GL_TEXTURE_*_ARRAY</code> target.
+	 *
+	 * @param array Whether the texture is an array texture
+	 */
+	public void setArray(boolean array) {
+		isArray = array;
+	}
+
+	/**
+	 * Returns whether mipmaps should be generated.
+	 *
+	 * See {@link #setGenerateMipmaps(boolean)}
+	 *
+	 * @return Whether mipmaps should be generated
+	 */
+	public boolean isGenerateMipmaps() {
+		return generateMipmaps;
+	}
+
+	/**
+	 * Set whether mipmaps should be generated.<br>
+	 * <br>
+	 * This indicates whether mipmaps should be generated for the texture when loading into a 3D API.
+	 *
+	 * @param generateMipmaps Whether mipmaps should be generated
+	 */
+	public void setGenerateMipmaps(boolean generateMipmaps) {
+		this.generateMipmaps = generateMipmaps;
+	}
+
+	/**
+	 * Returns the {@link VkFormat} for the texture.
+	 *
+	 * See {@link #setVkFormat(int)}
+	 *
+	 * @return The {@link VkFormat}
+	 */
+	public int getVkFormat() {
+		return this.vkFormat;
+	}
+
+	/**
+	 * Set the {@link VkFormat} for the texture.<br>
+	 * <br>
+	 * Ignored when creating a {@link KtxTexture1}.
+	 *
+	 * @param vkFormat The {@link VkFormat}
+	 */
+	public void setVkFormat(int vkFormat) {
+		this.vkFormat = vkFormat;
+	}
 }
diff --git a/interface/java_binding/src/main/java/org/khronos/ktx/KtxTextureCreateStorage.java b/interface/java_binding/src/main/java/org/khronos/ktx/KtxTextureCreateStorage.java
new file mode 100644
index 0000000000..a7649e3b69
--- /dev/null
+++ b/interface/java_binding/src/main/java/org/khronos/ktx/KtxTextureCreateStorage.java
@@ -0,0 +1,47 @@
+/*
+ * Copyright (c) 2021, Shukant Pal and Contributors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package org.khronos.ktx;
+
+/**
+ * Enum for requesting, or not, allocation of storage for images.<br>
+ * <br>
+ * These are passed to the {@link KtxTexture1#create(KtxTextureCreateInfo, int)}
+ * and {@link KtxTexture2#create(KtxTextureCreateInfo, int)} methods.
+ */
+public class KtxTextureCreateStorage {
+	/**
+	 * Don't allocate any image storage
+	 */
+    public static final int NO_STORAGE = 0;
+
+    /**
+     * Allocate image storage.
+     */
+    public static final int ALLOC_STORAGE = 1;
+
+	/**
+	 * Returns a string representation of the given storage mode
+	 *
+	 * @param n The storage mode
+	 * @return A string representation of the given storage mode
+	 */
+	public static String stringFor(int n) {
+		switch (n) {
+		case NO_STORAGE:
+			return "NO_STORAGE";
+		case ALLOC_STORAGE:
+			return "ALLOC_STORAGE";
+		}
+		return "[Unknown KtxTextureCreateStorage]";
+	}
+
+	/**
+	 * Private constructor to prevent instantiation
+	 */
+	private KtxTextureCreateStorage() {
+		// Prevent instantiation
+	}
+}
diff --git a/interface/java_binding/src/main/java/org/khronos/ktx/KtxTranscodeFlagBits.java b/interface/java_binding/src/main/java/org/khronos/ktx/KtxTranscodeFlagBits.java
new file mode 100644
index 0000000000..9bf45d2093
--- /dev/null
+++ b/interface/java_binding/src/main/java/org/khronos/ktx/KtxTranscodeFlagBits.java
@@ -0,0 +1,80 @@
+/*
+ * Copyright (c) 2024, Khronos Group and Contributors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package org.khronos.ktx;
+
+/**
+ * Flags guiding transcoding of Basis Universal compressed textures.<br>
+ * <br>
+ * These are passed to {@link KtxTexture2#transcodeBasis(int, int)}.
+ */
+public class KtxTranscodeFlagBits {
+
+	/**
+	 * PVRTC1: decode non-pow2 ETC1S texture level to the next larger
+	 * power of 2 (not implemented yet, but we're going to support it).
+	 * Ignored if the slice's dimensions are already a power of 2.
+	 */
+	public static final int PVRTC_DECODE_TO_NEXT_POW2 = 2;
+
+	/**
+	 * When decoding to an opaque texture format, if the Basis data has
+	 * alpha, decode the alpha slice instead of the color slice to the
+	 * output texture format. Has no effect if there is no alpha data.
+	 */
+	public static final int TRANSCODE_ALPHA_DATA_TO_OPAQUE_FORMATS = 4;
+
+	/**
+	 * Request higher quality transcode of UASTC to BC1, BC3, ETC2_EAC_R11 and
+	 * ETC2_EAC_RG11. The flag is unused by other UASTC transcoders.
+	 */
+	public static final int HIGH_QUALITY = 32;
+
+	/**
+	 * Returns a string representation of the given flag bits
+	 *
+	 * @param n The flag bits
+	 * @return A string representation of the given flag bits
+	 */
+	public static String stringFor(int n) {
+		if (n == 0)
+		{
+			return "(none)";
+		}
+		StringBuilder sb = new StringBuilder();
+		if ((n & PVRTC_DECODE_TO_NEXT_POW2) != 0) {
+			if (sb.length() != 0) {
+				sb.append("|");
+			}
+			sb.append("PVRTC_DECODE_TO_NEXT_POW2");
+		}
+		if ((n & TRANSCODE_ALPHA_DATA_TO_OPAQUE_FORMATS) != 0) {
+			if (sb.length() != 0) {
+				sb.append("|");
+			}
+			sb.append("TRANSCODE_ALPHA_DATA_TO_OPAQUE_FORMATS");
+		}
+		if ((n & HIGH_QUALITY) != 0) {
+			if (sb.length() != 0) {
+				sb.append("|");
+			}
+			sb.append("HIGH_QUALITY");
+		}
+		if (sb.length() == 0)
+		{
+			return "[Unknown KtxTranscodeFlagBits]";
+		}
+		return sb.toString();
+	}
+
+	/**
+	 * Private constructor to prevent instantiation
+	 */
+	private KtxTranscodeFlagBits() {
+		// Prevent instantiation
+	}
+
+
+}
diff --git a/interface/java_binding/src/main/java/org/khronos/ktx/KtxTranscodeFormat.java b/interface/java_binding/src/main/java/org/khronos/ktx/KtxTranscodeFormat.java
index 88978459e2..2975dbd79a 100644
--- a/interface/java_binding/src/main/java/org/khronos/ktx/KtxTranscodeFormat.java
+++ b/interface/java_binding/src/main/java/org/khronos/ktx/KtxTranscodeFormat.java
@@ -1,30 +1,192 @@
 /*
+ * Copyright (c) 2024, Khronos Group and Contributors
  * Copyright (c) 2021, Shukant Pal and Contributors
  * SPDX-License-Identifier: Apache-2.0
  */
 
 package org.khronos.ktx;
 
+/**
+ * Enumerators for specifying the transcode target format.<br>
+ * <br>
+ * For BasisU/ETC1S format, Opaque and alpha here refer to 2 separate RGB
+ * images, a.k.a slices within the BasisU compressed data. For UASTC format they
+ * refer to the RGB and the alpha components of the UASTC data. If the original
+ * image had only 2 components, R will be in the opaque portion and G in the
+ * alpha portion. The R value will be replicated in the RGB components. In the
+ * case of BasisU the G value will be replicated in all 3 components of the
+ * alpha slice. If the original image had only 1 component it's value is
+ * replicated in all 3 components of the opaque portion and there is no alpha.<br>
+ * <br>
+ * You should not transcode sRGB encoded data to <code>BC4_R</code>,
+ * <code>BC5_RG</code>, <code>ETC2_EAC_R{,G}11</code>, <code>RGB565</code>,
+ * <code>BGR565</code> or <code>RGBA4444</code> formats as neither OpenGL nor
+ * Vulkan support sRGB variants of these. Doing sRGB decoding in the shader will
+ * not produce correct results if any texture filtering is being used.
+ */
 public class KtxTranscodeFormat {
-    public static final int ETC1_RGB = 0;
-    public static final int ETC2_RGBA = 1;
-    public static final int BC1_RGB = 2;
-    public static final int BC3_RGBA = 3;
-    public static final int BC4_R = 4;
-    public static final int BC5_RG = 5;
-    public static final int BC7_RGBA = 6;
-    public static final int PVRTC1_4_RGB = 8;
-    public static final int PVRTC1_4_RGBA = 9;
-    public static final int ASTC_4x4_RGBA = 10;
-    public static final int PVRTC2_4_RGB = 18;
-    public static final int PVRTC2_4_RGBA = 19;
-    public static final int ETC2_EAC_R11 = 20;
-    public static final int ETC2_EAC_RG11 = 21;
-    public static final int RGBA32 = 13;
-    public static final int RGB565 = 14;
-    public static final int BGR565 = 15;
-    public static final int RGBA4444 = 16;
-    public static final int ETC = 22;
-    public static final int BC1_OR_3 = 23;
-    public static final int NOSELECTION = 0x7fffffff;
+
+	/**
+	 * Opaque only. Returns RGB or alpha data, if
+	 * {@link KtxTranscodeFlagBits#TRANSCODE_ALPHA_DATA_TO_OPAQUE_FORMATS} flag is specified.
+	 */
+	public static final int ETC1_RGB = 0;
+
+	/**
+	 * Opaque+alpha. EAC_A8 block followed by an ETC1 block. The alpha channel will
+	 * be opaque for textures without an alpha channel.
+	 */
+	public static final int ETC2_RGBA = 1;
+
+	/**
+	 * Opaque only, no punchthrough alpha support yet. Returns RGB or alpha data, if
+	 * {@link KtxTranscodeFlagBits#TRANSCODE_ALPHA_DATA_TO_OPAQUE_FORMATS} flag is specified.
+	 */
+	public static final int BC1_RGB = 2;
+
+	/**
+	 * Opaque+alpha. BC4 block with alpha followed by a BC1 block. The alpha channel
+	 * will be opaque for textures without an alpha channel.
+	 */
+	public static final int BC3_RGBA = 3;
+
+	/**
+	 * One BC4 block. R = opaque.g or alpha.g, if
+	 * {@link KtxTranscodeFlagBits#TRANSCODE_ALPHA_DATA_TO_OPAQUE_FORMATS} flag is specified.
+	 */
+	public static final int BC4_R = 4;
+
+	/**
+	 * Two BC4 blocks, R=opaque.g and G=alpha.g The texture should have an alpha
+	 * channel (if not G will be all 255's. For tangent space normal maps.
+	 */
+	public static final int BC5_RG = 5;
+
+	/**
+	 * RGB or RGBA mode 5 for ETC1S, modes 1, 2, 3, 4, 5, 6, 7 for UASTC.
+	 */
+	public static final int BC7_RGBA = 6;
+
+	/**
+	 * Opaque only. Returns RGB or alpha data, if
+	 * {@link KtxTranscodeFlagBits#TRANSCODE_ALPHA_DATA_TO_OPAQUE_FORMATS} flag is specified.
+	 */
+	public static final int PVRTC1_4_RGB = 8;
+
+	/**
+	 * Opaque+alpha. Most useful for simple opacity maps. If the texture doesn't
+	 * have an alpha channel PVRTC1_4_RGB will be used instead. Lowest quality of
+	 * any supported texture format.
+	 */
+	public static final int PVRTC1_4_RGBA = 9;
+
+	/**
+	 * Opaque+alpha, ASTC 4x4. The alpha channel will be opaque for textures without
+	 * an alpha channel. The transcoder uses RGB/RGBA/L/LA modes, void extent, and
+	 * up to two ([0,47] and [0,255]) endpoint precisions.
+	 */
+	public static final int ASTC_4x4_RGBA = 10;
+
+	/**
+	 * Opaque-only. Almost BC1 quality, much faster to transcode and supports
+	 * arbitrary texture dimensions (unlike PVRTC1 RGB).
+	 */
+	public static final int PVRTC2_4_RGB = 18;
+
+	/**
+	 * Opaque+alpha. Slower to transcode than cTFPVRTC2_4_RGB. Premultiplied alpha
+	 * is highly recommended, otherwise the color channel can leak into the alpha
+	 * channel on transparent blocks.
+	 */
+	public static final int PVRTC2_4_RGBA = 19;
+
+	/**
+	 * R only (ETC2 EAC R11 unsigned). R = opaque.g or alpha.g, if
+	 * {@link KtxTranscodeFlagBits#TRANSCODE_ALPHA_DATA_TO_OPAQUE_FORMATS} flag is specified.
+	 */
+	public static final int ETC2_EAC_R11 = 20;
+
+	/**
+	 * RG only (ETC2 EAC RG11 unsigned), R=opaque.g, G=alpha.g. The texture should
+	 * have an alpha channel (if not G will be all 255's. For tangent space normal
+	 * maps.
+	 */
+	public static final int ETC2_EAC_RG11 = 21;
+
+	/**
+	 * 32bpp RGBA image stored in raster (not block) order in memory, R is first
+	 * byte, A is last byte.
+	 */
+	public static final int RGBA32 = 13;
+
+	/**
+	 * 16bpp RGB image stored in raster (not block) order in memory, R at bit
+	 * position 11.
+	 */
+	public static final int RGB565 = 14;
+
+	/**
+	 * 16bpp RGB image stored in raster (not block) order in memory, R at bit
+	 * position 0.
+	 */
+	public static final int BGR565 = 15;
+
+	/**
+	 * 16bpp RGBA image stored in raster (not block) order in memory, R at bit
+	 * position 12, A at bit position 0.
+	 */
+	public static final int RGBA4444 = 16;
+
+	/**
+	 * Automatically selects ETC1_RGB or ETC2_RGBA according to presence of alpha.
+	 */
+	public static final int ETC = 22;
+
+	/**
+	 * Automatically selects BC1_RGB or BC3_RGBA according to presence of alpha.
+	 */
+	public static final int BC1_OR_3 = 23;
+
+	public static final int NOSELECTION = 0x7fffffff;
+
+	/**
+	 * Returns a string representation of the given transcode format
+	 *
+	 * @param n The transcode format
+	 * @return A string representation of the given transcode format
+	 */
+	public static String stringFor(int n) {
+		switch (n) {
+		case ETC1_RGB: return "ETC1_RGB";
+		case ETC2_RGBA: return "ETC2_RGBA";
+		case BC1_RGB: return "BC1_RGB";
+		case BC3_RGBA: return "BC3_RGBA";
+		case BC4_R: return "BC4_R";
+		case BC5_RG: return "BC5_RG";
+		case BC7_RGBA: return "BC7_RGBA";
+		case PVRTC1_4_RGB: return "PVRTC1_4_RGB";
+		case PVRTC1_4_RGBA: return "PVRTC1_4_RGBA";
+		case ASTC_4x4_RGBA: return "ASTC_4x4_RGBA";
+		case PVRTC2_4_RGB: return "PVRTC2_4_RGB";
+		case PVRTC2_4_RGBA: return "PVRTC2_4_RGBA";
+		case ETC2_EAC_R11: return "ETC2_EAC_R11";
+		case ETC2_EAC_RG11: return "ETC2_EAC_RG11";
+		case RGBA32: return "RGBA32";
+		case RGB565: return "RGB565";
+		case BGR565: return "BGR565";
+		case RGBA4444: return "RGBA4444";
+		case ETC: return "ETC";
+		case BC1_OR_3: return "BC1_OR_3";
+		case NOSELECTION: return "NOSELECTION";
+		}
+		return "[Unknown KtxTranscodeFormat]";
+	}
+
+	/**
+	 * Private constructor to prevent instantiation
+	 */
+	private KtxTranscodeFormat() {
+		// Prevent instantiation
+	}
+
 }
diff --git a/interface/java_binding/src/test/java/org/khronos/ktx/test/KtxAstcParamsTest.java b/interface/java_binding/src/test/java/org/khronos/ktx/test/KtxAstcParamsTest.java
new file mode 100644
index 0000000000..094694f34b
--- /dev/null
+++ b/interface/java_binding/src/test/java/org/khronos/ktx/test/KtxAstcParamsTest.java
@@ -0,0 +1,46 @@
+/*
+ * Copyright (c) 2024, Khronos Group and Contributors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package org.khronos.ktx.test;
+
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+import java.io.IOException;
+
+import org.junit.jupiter.api.Test;
+import org.khronos.ktx.KtxAstcParams;
+
+public class KtxAstcParamsTest {
+	@Test
+	public void testValidSwizzle() {
+		KtxAstcParams p = new KtxAstcParams();
+		p.setInputSwizzle(new char[] { 'a', '1', 'r', '0' });
+		assertTrue(true, "Accepts valid swizzle");
+	}
+
+	@Test
+	public void testNullSwizzle() {
+		KtxAstcParams p = new KtxAstcParams();
+		p.setInputSwizzle(null);
+		assertTrue(true, "Accepts null swizzle (to apply no swizzle)");
+	}
+
+	@Test
+	public void testInvalidSwizzleLength() throws IOException {
+		KtxAstcParams p = new KtxAstcParams();
+		assertThrows(IllegalArgumentException.class,
+				() -> p.setInputSwizzle(new char[] { 'a', 'b', 'r', 'g', 'r', 'g' }),
+				"Swizzle length != 4 expected to throw IllegalArgumentException");
+	}
+
+	@Test
+	public void testInvalidSwizzleChar() throws IOException {
+
+		KtxAstcParams p = new KtxAstcParams();
+		assertThrows(IllegalArgumentException.class, () -> p.setInputSwizzle(new char[] { 'a', 'b', 'X', 'g' }),
+				"Invalid swizzle character expected to throw IllegalArgumentException");
+	}
+}
diff --git a/interface/java_binding/src/test/java/org/khronos/ktx/test/KtxParallelTest.java b/interface/java_binding/src/test/java/org/khronos/ktx/test/KtxParallelTest.java
index a9bcea4b61..2bf96c25b7 100644
--- a/interface/java_binding/src/test/java/org/khronos/ktx/test/KtxParallelTest.java
+++ b/interface/java_binding/src/test/java/org/khronos/ktx/test/KtxParallelTest.java
@@ -45,7 +45,7 @@ public KtxTestRun(int id) {
 
         public void run() {
             // Repeatedly create a compress an image.
-            for (int i = 0; i < 300; i++) {
+            for (int i = 0; i < 30; i++) {
                 final int w = (testRandomizer.nextInt() % 512) + 1024;
                 final int h = w;
                 final int size = convertToASTC(w, h);
@@ -61,7 +61,7 @@ public int convertToASTC(int w, int h) {
             info.setBaseWidth(w);
             info.setBaseHeight(h);
             info.setVkFormat(VkFormat.VK_FORMAT_R8G8B8_SRGB); // Uncompressed
-            final KtxTexture2 t = KtxTexture2.create(info, KtxCreateStorage.ALLOC);
+            final KtxTexture2 t = KtxTexture2.create(info, KtxTextureCreateStorage.ALLOC_STORAGE);
 
             // Pass the uncompressed data
             int bufferSize = w * h * 3;
diff --git a/interface/java_binding/src/test/java/org/khronos/ktx/test/KtxTestLibraryLoader.java b/interface/java_binding/src/test/java/org/khronos/ktx/test/KtxTestLibraryLoader.java
index 1964739f5d..686dd68282 100644
--- a/interface/java_binding/src/test/java/org/khronos/ktx/test/KtxTestLibraryLoader.java
+++ b/interface/java_binding/src/test/java/org/khronos/ktx/test/KtxTestLibraryLoader.java
@@ -1,62 +1,112 @@
 /*
  * Copyright (c) 2021, Shukant Pal and Contributors
+ * Copyright (c) 2024, Khronos Group and Contributors
  * SPDX-License-Identifier: Apache-2.0
  */
 
 package org.khronos.ktx.test;
 
-import org.junit.jupiter.api.extension.BeforeAllCallback;
-import org.junit.jupiter.api.extension.ExtensionContext;
-
 import java.io.File;
 import java.nio.file.Files;
 import java.nio.file.Path;
+import java.util.Locale;
+
+import org.junit.jupiter.api.extension.BeforeAllCallback;
+import org.junit.jupiter.api.extension.ExtensionContext;
+
+/**
+ * A class that will be used for extending the unit tests, and allow using the
+ * native <code>ktx</code> and <code>ktx-jni</code> libraries from <i>any</i>
+ * directory for the tests.
+ *
+ * (Usually, this will be a local build output directory)
+ *
+ * It will check the <code>LIBKTX_BINARY_DIR<code> environment variable. If this
+ * environment variable is a directory that contains the KTX JNI library, then
+ * this library will be loaded.
+ *
+ * Otherwise, it will load the KTX JNI library that was installed globally with
+ * the usual installation procedure.
+ */
+public class KtxTestLibraryLoader implements BeforeAllCallback, ExtensionContext.Store.CloseableResource {
+	private static boolean started = false;
+
+	@Override
+	public void beforeAll(final ExtensionContext context) throws Exception {
+
+		if (started) {
+			return;
+		}
+		started = true;
+
+		String ktxJniLibrary = findKtxJniLibraryName();
+		if (ktxJniLibrary != null) {
+			System.load(ktxJniLibrary);
+		} else {
+			System.loadLibrary("ktx-jni");
+		}
+	}
+
+	/**
+	 * Try to find the name (full, absolute path) of the KTX JNI library that should
+	 * be loaded.
+	 *
+	 * This method will search for the library in the directory that is defined via
+	 * the <code>LIBKTX_BINARY_DIR</code> environment variable. If this variable is
+	 * not defined, or no suitable library can be found, then <code>null</code> is
+	 * returned.
+	 *
+	 * @return The KTX JNI library name
+	 */
+	private static String findKtxJniLibraryName() {
+		String ktxDir = System.getenv("LIBKTX_BINARY_DIR");
+		if (ktxDir == null) {
+			return null;
+		}
+
+		Path ktxPath = Path.of(ktxDir);
+		if (!ktxPath.isAbsolute() || !Files.exists(ktxPath) || !Files.isDirectory(ktxPath)) {
+			System.out.println(
+					"KTXTestLibraryLoader: The value of the LIBKTX_BINARY_DIR environment variable is invalid: "
+							+ ktxDir);
+			return null;
+		}
+
+		String expectedKtxJniLibraryName = isRunningOnWindows() ? "ktx-jni" : "libktx-jni";
+
+		System.out.println("KTXTestLibraryLoader: Loading KTX libraries from " + ktxDir);
+		File ktxDirFile = new File(ktxDir);
+		for (File file : ktxDirFile.listFiles()) {
+			if (!file.isFile()) {
+				continue;
+			}
+			String[] tokens = file.getName().split("\\.");
+			if (tokens.length == 2 && tokens[0].equals(expectedKtxJniLibraryName)) {
+
+				String ktxJniLibrary = file.getAbsolutePath();
+				System.out.println("KTXTestLibraryLoader: Found " + expectedKtxJniLibraryName + " at " + ktxJniLibrary);
+				return ktxJniLibrary;
+			}
+		}
+		System.out
+				.println("KTXTestLibraryLoader: Could not find " + expectedKtxJniLibraryName + " in given directory");
+		return null;
+	}
+
+	/**
+	 * Returns whether the <code>os.name</code> system property indicates that the
+	 * operating system is Windows.
+	 *
+	 * @return Whether the operating system is Windows
+	 */
+	private static boolean isRunningOnWindows() {
+		String osName = System.getProperty("os.name");
+		osName = osName.toLowerCase(Locale.ENGLISH);
+		return osName.startsWith("windows");
+	}
 
-public class KtxTestLibraryLoader
-        implements BeforeAllCallback, ExtensionContext.Store.CloseableResource {
-    private static boolean started = false;
-
-    @Override
-    public void beforeAll(final ExtensionContext context) throws Exception {
-        if (!started) {
-            started = true;
-
-            String ktxDir = System.getenv("LIBKTX_BINARY_DIR");
-            String ktxJNILibrary = null;
-
-            if (ktxDir != null &&
-                    Path.of(ktxDir).isAbsolute() &&
-                    Files.exists(Path.of(ktxDir)) &&
-                    Files.isDirectory(Path.of(ktxDir))) {
-                System.out.println("KTXTestLibraryLoader is loading libktx, libktx-jni from " + ktxDir);
-
-                File ktxDirFile = new File(ktxDir);
-
-                for (File file : ktxDirFile.listFiles()) {
-                    if (!file.isFile()) continue;
-                    if (ktxJNILibrary != null) break;
-
-                    String[] tokens = file.getName().split("\\.");
-
-                    if (ktxJNILibrary == null &&
-                            tokens.length == 2 &&
-                            tokens[0].contentEquals("libktx-jni")) {
-
-                        ktxJNILibrary = file.getAbsolutePath();
-                        System.out.println("KTXTestLibraryLoader found libktx-jni at " + ktxJNILibrary);
-                    }
-                }
-            }
-
-            if (ktxJNILibrary != null)
-                System.load(ktxJNILibrary);
-            else
-                System.loadLibrary("ktx-jni");
-        }
-    }
-
-    @Override
-    public void close() {
-        // NOOP
-    }
+	@Override
+	public void close() {
+		// NOOP
+	}
 }
diff --git a/interface/java_binding/src/test/java/org/khronos/ktx/test/KtxTexture1Test.java b/interface/java_binding/src/test/java/org/khronos/ktx/test/KtxTexture1Test.java
index 865751f1ae..7b4a69aa94 100644
--- a/interface/java_binding/src/test/java/org/khronos/ktx/test/KtxTexture1Test.java
+++ b/interface/java_binding/src/test/java/org/khronos/ktx/test/KtxTexture1Test.java
@@ -108,7 +108,7 @@ public void testCreate() {
         info.setBaseWidth(10);
         info.setBaseHeight(10);
 
-        KtxTexture1 texture = KtxTexture1.create(info, KtxCreateStorage.ALLOC);
+        KtxTexture1 texture = KtxTexture1.create(info, KtxTextureCreateStorage.ALLOC_STORAGE);
         assertNotNull(texture);
 
         byte[] imageData = new byte[10 * 10];
diff --git a/interface/java_binding/src/test/java/org/khronos/ktx/test/KtxTexture2Test.java b/interface/java_binding/src/test/java/org/khronos/ktx/test/KtxTexture2Test.java
index 48db332084..2518bc8cbd 100644
--- a/interface/java_binding/src/test/java/org/khronos/ktx/test/KtxTexture2Test.java
+++ b/interface/java_binding/src/test/java/org/khronos/ktx/test/KtxTexture2Test.java
@@ -1,5 +1,6 @@
 /*
  * Copyright (c) 2021, Shukant Pal and Contributors
+ * Copyright (c) 2024, Khronos Group and Contributors
  * SPDX-License-Identifier: Apache-2.0
  */
 
@@ -8,8 +9,11 @@
 import static org.junit.jupiter.api.Assertions.assertArrayEquals;
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertTrue;
 
 import java.io.IOException;
+import java.nio.ByteBuffer;
 import java.nio.file.Files;
 import java.nio.file.Path;
 import java.nio.file.Paths;
@@ -17,8 +21,9 @@
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.extension.ExtendWith;
 import org.khronos.ktx.KtxBasisParams;
-import org.khronos.ktx.KtxCreateStorage;
+import org.khronos.ktx.KtxTextureCreateStorage;
 import org.khronos.ktx.KtxErrorCode;
+import org.khronos.ktx.KtxException;
 import org.khronos.ktx.KtxSupercmpScheme;
 import org.khronos.ktx.KtxTexture2;
 import org.khronos.ktx.KtxTextureCreateFlagBits;
@@ -37,7 +42,7 @@ public void testCreateFromNamedFile() {
                 .normalize();
 
         KtxTexture2 texture = KtxTexture2.createFromNamedFile(testKtxFile.toString(),
-                                                            KtxTextureCreateFlagBits.NO_FLAGS);
+                KtxTextureCreateFlagBits.NO_FLAGS);
 
         assertNotNull(texture);
         assertEquals(texture.getNumLevels(), 1);
@@ -50,6 +55,125 @@ public void testCreateFromNamedFile() {
         texture.destroy();
     }
 
+    @Test
+    public void testCreateWithInvalidParameters() {
+
+        KtxTextureCreateInfo info = new KtxTextureCreateInfo();
+        info.setBaseWidth(128);
+        info.setBaseHeight(128);
+        info.setNumDimensions(-123); // Invalid!
+        info.setVkFormat(VkFormat.VK_FORMAT_R8G8B8A8_SRGB);
+
+        assertThrows(KtxException.class,
+                () -> KtxTexture2.create(info, KtxTextureCreateStorage.ALLOC_STORAGE),
+                "Expected to throw NullPointerException");
+    }
+
+    @Test
+    public void testCreateFromMemoryBasic() {
+
+        // Create a texture, and write it to memory
+        int sizeX = 512;
+        int sizeY = 512;
+        KtxTextureCreateInfo info = new KtxTextureCreateInfo();
+        info.setBaseWidth(sizeX);
+        info.setBaseHeight(sizeY);
+        info.setVkFormat(VkFormat.VK_FORMAT_R8G8B8A8_SRGB);
+        KtxTexture2 input = KtxTexture2.create(info, KtxTextureCreateStorage.ALLOC_STORAGE);
+        byte[] inputMemoryArray = input.writeToMemory();
+
+        // Create the texture from the exact memory
+        int createFlags = KtxTextureCreateFlagBits.LOAD_IMAGE_DATA_BIT;
+        KtxTexture2 t = KtxTexture2.createFromMemory(ByteBuffer.wrap(inputMemoryArray), createFlags);
+
+        // Ensure that the image has the same basic properties
+        // as the one that it was created from
+        assertEquals(t.getBaseWidth(), 512);
+        assertEquals(t.getBaseHeight(), 512);
+    }
+
+    @Test
+    public void testCreateFromMemoryWithPositionAndLimit() {
+
+        // Create a texture, and write it to memory
+        int sizeX = 512;
+        int sizeY = 512;
+        KtxTextureCreateInfo info = new KtxTextureCreateInfo();
+        info.setBaseWidth(sizeX);
+        info.setBaseHeight(sizeY);
+        info.setVkFormat(VkFormat.VK_FORMAT_R8G8B8A8_SRGB);
+        KtxTexture2 input = KtxTexture2.create(info, KtxTextureCreateStorage.ALLOC_STORAGE);
+        byte[] inputMemoryArray = input.writeToMemory();
+
+        // Create a byte buffer that is a bit larger than
+        // the input memory, and put the input memory
+        // into it, at position 50
+        ByteBuffer largeBuffer = ByteBuffer.wrap(new byte[inputMemoryArray.length + 100]);
+        largeBuffer.position(50);
+        largeBuffer.put(inputMemoryArray);
+
+        // Set the position and limit of the buffer to
+        // reflect the range that actually contains
+        // the real input data
+        largeBuffer.position(50);
+        largeBuffer.limit(50 + inputMemoryArray.length);
+
+        // Create the texture from the exact memory
+        int createFlags = KtxTextureCreateFlagBits.LOAD_IMAGE_DATA_BIT;
+        KtxTexture2 t = KtxTexture2.createFromMemory(largeBuffer, createFlags);
+
+        // Ensure that the image has the same basic properties
+        // as the one that it was created from
+        assertEquals(t.getBaseWidth(), 512);
+        assertEquals(t.getBaseHeight(), 512);
+    }
+
+    @Test
+    public void testCreateFromDirectMemoryWithPositionAndLimit() {
+
+        // Create a texture, and write it to memory
+        int sizeX = 512;
+        int sizeY = 512;
+        KtxTextureCreateInfo info = new KtxTextureCreateInfo();
+        info.setBaseWidth(sizeX);
+        info.setBaseHeight(sizeY);
+        info.setVkFormat(VkFormat.VK_FORMAT_R8G8B8A8_SRGB);
+        KtxTexture2 input = KtxTexture2.create(info, KtxTextureCreateStorage.ALLOC_STORAGE);
+        byte[] inputMemoryArray = input.writeToMemory();
+
+        // Create a DIRECT byte buffer that is a bit larger than
+        // the input memory, and put the input memory
+        // into it, at position 50
+        ByteBuffer largeBuffer = ByteBuffer.allocateDirect(inputMemoryArray.length + 100);
+        largeBuffer.position(50);
+        largeBuffer.put(inputMemoryArray);
+
+        // Set the position and limit of the buffer to
+        // reflect the range that actually contains
+        // the real input data
+        largeBuffer.position(50);
+        largeBuffer.limit(50 + inputMemoryArray.length);
+
+        // Create the texture from the exact memory
+        int createFlags = KtxTextureCreateFlagBits.LOAD_IMAGE_DATA_BIT;
+        KtxTexture2 t = KtxTexture2.createFromMemory(largeBuffer, createFlags);
+
+        // Ensure that the image has the same basic properties
+        // as the one that it was created from
+        assertEquals(t.getBaseWidth(), 512);
+        assertEquals(t.getBaseHeight(), 512);
+    }
+
+
+
+    @Test
+    public void testCreateFromNamedFileWithNull() {
+
+        assertThrows(NullPointerException.class,
+                () -> KtxTexture2.createFromNamedFile(null, KtxTextureCreateFlagBits.NO_FLAGS),
+                "Expected to throw NullPointerException");
+    }
+
     @Test
     public void testCreateFromNamedFileMipmapped() {
         Path testKtxFile = Paths.get("")
@@ -203,6 +327,58 @@ public void testCompressBasisEx() {
         texture.destroy();
     }
 
+    @Test
+    public void testUsingAfterDestroy() {
+        KtxTextureCreateInfo info = new KtxTextureCreateInfo();
+        info.setBaseWidth(16);
+        info.setBaseHeight(16);
+        info.setVkFormat(VkFormat.VK_FORMAT_ASTC_4x4_SRGB_BLOCK);
+        KtxTexture2 texture = KtxTexture2.create(info, KtxTextureCreateStorage.ALLOC_STORAGE);
+
+        // Call destroy, and then try to call a function.
+        // It should throw for ALL functions, and there
+        // should be a test for EACH function, but...
+        // I got stuff to do, you know...
+        texture.destroy();
+        assertThrows(IllegalStateException.class,
+                () -> texture.getBaseDepth(),
+                "Expected to throw IllegalStateException");
+
+    }
+
+    @Test
+    public void testDestroyMultipleTimes() {
+        KtxTextureCreateInfo info = new KtxTextureCreateInfo();
+        info.setBaseWidth(16);
+        info.setBaseHeight(16);
+        info.setVkFormat(VkFormat.VK_FORMAT_ASTC_4x4_SRGB_BLOCK);
+        KtxTexture2 texture = KtxTexture2.create(info, KtxTextureCreateStorage.ALLOC_STORAGE);
+
+        texture.destroy();
+        texture.destroy();
+        texture.destroy();
+
+        assertTrue(true, "Should be able to call destroy() multiple times");
+    }
+
+
+    @Test
+    public void testCompressBasisExWithNull() {
+        KtxTextureCreateInfo info = new KtxTextureCreateInfo();
+        info.setBaseWidth(16);
+        info.setBaseHeight(16);
+        info.setVkFormat(VkFormat.VK_FORMAT_ASTC_4x4_SRGB_BLOCK);
+        KtxTexture2 texture = KtxTexture2.create(info, KtxTextureCreateStorage.ALLOC_STORAGE);
+
+        assertThrows(NullPointerException.class,
+                () -> texture.compressBasisEx(null),
+                "Expected to throw NullPointerException");
+
+        texture.destroy();
+    }
+
+
+
     @Test
     public void testTranscodeBasis() {
         Path testKtxFile = Paths.get("")
@@ -228,7 +404,7 @@ public void testCreate() {
         info.setBaseHeight(10);
         info.setVkFormat(VkFormat.VK_FORMAT_ASTC_4x4_SRGB_BLOCK);
 
-        KtxTexture2 texture = KtxTexture2.create(info, KtxCreateStorage.ALLOC);
+        KtxTexture2 texture = KtxTexture2.create(info, KtxTextureCreateStorage.ALLOC_STORAGE);
         assertNotNull(texture);
 
         byte[] imageData = new byte[10 * 10];
@@ -237,90 +413,190 @@ public void testCreate() {
         texture.destroy();
     }
 
-	@Test
-	public void testInputSwizzleBasisEx() throws IOException {
-
-		int sizeX = 32;
-		int sizeY = 32;
-		int outputFormat = KtxTranscodeFormat.RGBA32;
-		int transcodeFlags = 0;
-
-		// Create the actual texture data:
-		// - create RGBA pixels
-		// - create texture
-		// - compress with BRGA input swizzling
-		// - obtain resulting RGBA values
-
-		// Create a RGBA pixels for an image filled with
-		// 8 rows of red pixels
-		// 8 rows of green pixels
-		// 8 rows of blue pixels
-		// 8 rows of white pixels
-		byte[] input = new byte[sizeX * sizeY * 4];
-		TestUtils.fillRows(input, sizeX, sizeY, 0, 8, 255, 0, 0, 255); // Red
-		TestUtils.fillRows(input, sizeX, sizeY, 8, 16, 0, 255, 0, 255); // Green
-		TestUtils.fillRows(input, sizeX, sizeY, 16, 24, 0, 0, 255, 255); // Blue
-		TestUtils.fillRows(input, sizeX, sizeY, 24, 32, 255, 255, 255, 255); // White
-
-		// Create the input texture from the pixels
-		KtxTextureCreateInfo inputInfo = new KtxTextureCreateInfo();
-		inputInfo.setBaseWidth(sizeX);
-		inputInfo.setBaseHeight(sizeY);
-		inputInfo.setVkFormat(VkFormat.VK_FORMAT_R8G8B8A8_SRGB);
-		KtxTexture2 inputTexture = KtxTexture2.create(inputInfo, KtxCreateStorage.ALLOC);
-		inputTexture.setImageFromMemory(0, 0, 0, input);
-
-		// Apply basis compression to the input, with an input swizzle BRGA,
-		// so that
-		// the former B channel becomes the R channel
-		// the former R channel becomes the G channel
-		// the former G channel becomes the B channel
-		// the former A channel remains the A channel
-		KtxBasisParams inputParams = new KtxBasisParams();
-		inputParams.setUastc(false);
-		inputParams.setInputSwizzle(new char[] { 'b', 'r', 'g', 'a' });
-		inputTexture.compressBasisEx(inputParams);
-
-		// Transcode the input texture to RGBA32
-		inputTexture.transcodeBasis(outputFormat, transcodeFlags);
-		byte[] actualRgba = inputTexture.getData();
-
-		// Create the expected reference data:
-		// - create RGBA pixels, swizzled with BRGA
-		// - create texture
-		// - compress without input swizzling
-		// - obtain resulting RGBA values
-
-		// Create "golden" reference pixels, where a BRGA
-		// swizzling was already applied
-		byte[] gold = new byte[sizeX * sizeY * 4];
-		TestUtils.fillRows(gold, sizeX, sizeY, 0, 8, 0, 255, 0, 255); // Green
-		TestUtils.fillRows(gold, sizeX, sizeY, 8, 16, 0, 0, 255, 255); // Blue
-		TestUtils.fillRows(gold, sizeX, sizeY, 16, 24, 255, 0, 0, 255); // Red
-		TestUtils.fillRows(gold, sizeX, sizeY, 24, 32, 255, 255, 255, 255); // White
-
-		// Create the reference texture from the swizzled pixels
-		KtxTextureCreateInfo goldInfo = new KtxTextureCreateInfo();
-		goldInfo.setBaseWidth(sizeX);
-		goldInfo.setBaseHeight(sizeY);
-		goldInfo.setVkFormat(VkFormat.VK_FORMAT_R8G8B8A8_SRGB);
-		KtxTexture2 goldTexture = KtxTexture2.create(goldInfo, KtxCreateStorage.ALLOC);
-		goldTexture.setImageFromMemory(0, 0, 0, gold);
-
-		// Apply basis compression to the reference, without swizzling
-		KtxBasisParams goldParams = new KtxBasisParams();
-		goldParams.setUastc(false);
-		goldTexture.compressBasisEx(goldParams);
-
-		// Transcode the reference texture to RGBA32
-		goldTexture.transcodeBasis(outputFormat, transcodeFlags);
-		byte[] expectedRgba = goldTexture.getData();
-
-		// Compare the resulting data to the expected RGBA values.
-		assertArrayEquals(expectedRgba, actualRgba);
-
-		inputTexture.destroy();
-		goldTexture.destroy();
-	}
-}
+    @Test
+    public void testCreateWithNull() {
+        assertThrows(NullPointerException.class,
+                () -> KtxTexture2.create(null, KtxTextureCreateStorage.ALLOC_STORAGE),
+                "Expected to throw NullPointerException");
+    }
+
+    @Test
+    void testSetImageFromMemoryWithNull() {
+        KtxTextureCreateInfo info = new KtxTextureCreateInfo();
+        info.setBaseWidth(16);
+        info.setBaseHeight(16);
+        info.setVkFormat(VkFormat.VK_FORMAT_R8G8B8A8_SRGB);
+        KtxTexture2 t = KtxTexture2.create(info, KtxTextureCreateStorage.ALLOC_STORAGE);
+
+        assertThrows(NullPointerException.class,
+                () -> t.setImageFromMemory(0, 0, 0, null),
+                "Expected to throw NullPointerException");
+    }
 
+    @Test
+    void testCreateFromMemoryWithInvalidMemory() {
+
+        byte[] invalidMemory = new byte[1000];
+        int createFlags = KtxTextureCreateFlagBits.LOAD_IMAGE_DATA_BIT;
+
+        assertThrows(KtxException.class,
+                () -> KtxTexture2.createFromMemory(ByteBuffer.wrap(invalidMemory), createFlags),
+                "Expected to throw NullPointerException");
+    }
+
+    @Test
+    public void testInputSwizzleBasisEx() throws IOException {
+
+        int sizeX = 32;
+        int sizeY = 32;
+        int outputFormat = KtxTranscodeFormat.RGBA32;
+        int transcodeFlags = 0;
+
+        // Create the actual texture data:
+        // - create RGBA pixels
+        // - create texture
+        // - compress with BRGA input swizzling
+        // - obtain resulting RGBA values
+
+        // Create a RGBA pixels for an image filled with
+        // 8 rows of red pixels
+        // 8 rows of green pixels
+        // 8 rows of blue pixels
+        // 8 rows of white pixels
+        byte[] input = new byte[sizeX * sizeY * 4];
+        TestUtils.fillRows(input, sizeX, sizeY, 0, 8, 255, 0, 0, 255); // Red
+        TestUtils.fillRows(input, sizeX, sizeY, 8, 16, 0, 255, 0, 255); // Green
+        TestUtils.fillRows(input, sizeX, sizeY, 16, 24, 0, 0, 255, 255); // Blue
+        TestUtils.fillRows(input, sizeX, sizeY, 24, 32, 255, 255, 255, 255); // White
+
+        // Create the input texture from the pixels
+        KtxTextureCreateInfo inputInfo = new KtxTextureCreateInfo();
+        inputInfo.setBaseWidth(sizeX);
+        inputInfo.setBaseHeight(sizeY);
+        inputInfo.setVkFormat(VkFormat.VK_FORMAT_R8G8B8A8_SRGB);
+        KtxTexture2 inputTexture = KtxTexture2.create(inputInfo,
+        		KtxTextureCreateStorage.ALLOC_STORAGE);
+        inputTexture.setImageFromMemory(0, 0, 0, input);
+
+        // Apply basis compression to the input, with an input swizzle BRGA,
+        // so that
+        // the former B channel becomes the R channel
+        // the former R channel becomes the G channel
+        // the former G channel becomes the B channel
+        // the former A channel remains the A channel
+        KtxBasisParams inputParams = new KtxBasisParams();
+        inputParams.setUastc(false);
+        inputParams.setInputSwizzle(new char[] { 'b', 'r', 'g', 'a' });
+        inputTexture.compressBasisEx(inputParams);
+
+        // Transcode the input texture to RGBA32
+        inputTexture.transcodeBasis(outputFormat, transcodeFlags);
+        byte[] actualRgba = inputTexture.getData();
+
+        // Create the expected reference data:
+        // - create RGBA pixels, swizzled with BRGA
+        // - create texture
+        // - compress without input swizzling
+        // - obtain resulting RGBA values
+
+        // Create "golden" reference pixels, where a BRGA
+        // swizzling was already applied
+        byte[] gold = new byte[sizeX * sizeY * 4];
+        TestUtils.fillRows(gold, sizeX, sizeY, 0, 8, 0, 255, 0, 255); // Green
+        TestUtils.fillRows(gold, sizeX, sizeY, 8, 16, 0, 0, 255, 255); // Blue
+        TestUtils.fillRows(gold, sizeX, sizeY, 16, 24, 255, 0, 0, 255); // Red
+        TestUtils.fillRows(gold, sizeX, sizeY, 24, 32, 255, 255, 255, 255); // White
+
+        // Create the reference texture from the swizzled pixels
+        KtxTextureCreateInfo goldInfo = new KtxTextureCreateInfo();
+        goldInfo.setBaseWidth(sizeX);
+        goldInfo.setBaseHeight(sizeY);
+        goldInfo.setVkFormat(VkFormat.VK_FORMAT_R8G8B8A8_SRGB);
+        KtxTexture2 goldTexture = KtxTexture2.create(goldInfo,
+        		KtxTextureCreateStorage.ALLOC_STORAGE);
+        goldTexture.setImageFromMemory(0, 0, 0, gold);
+
+        // Apply basis compression to the reference, without swizzling
+        KtxBasisParams goldParams = new KtxBasisParams();
+        goldParams.setUastc(false);
+        goldTexture.compressBasisEx(goldParams);
+
+        // Transcode the reference texture to RGBA32
+        goldTexture.transcodeBasis(outputFormat, transcodeFlags);
+        byte[] expectedRgba = goldTexture.getData();
+
+        // Compare the resulting data to the expected RGBA values.
+        assertArrayEquals(expectedRgba, actualRgba);
+
+        inputTexture.destroy();
+        goldTexture.destroy();
+    }
+
+    @Test
+    public void testSupercompressionZstd() throws IOException {
+
+        int sizeX = 32;
+        int sizeY = 32;
+
+        // Create a dummy texture
+        KtxTextureCreateInfo info = new KtxTextureCreateInfo();
+        info.setBaseWidth(sizeX);
+        info.setBaseHeight(sizeY);
+        info.setVkFormat(VkFormat.VK_FORMAT_R8G8B8A8_SRGB);
+        KtxTexture2 t = KtxTexture2.create(info, KtxTextureCreateStorage.ALLOC_STORAGE);
+        byte[] rgba = new byte[sizeX * sizeY * 4];
+        t.setImageFromMemory(0, 0, 0, rgba);
+
+        // Apply default UASTC compression
+        KtxBasisParams p = new KtxBasisParams();
+        p.setUastc(true);
+        t.compressBasisEx(p);
+
+        // The supercompression scheme should be NONE here
+        int scBefore = t.getSupercompressionScheme();
+        assertEquals(KtxSupercmpScheme.NONE, scBefore);
+
+        // Apply Zstd compression
+        t.deflateZstd(10);
+
+        // The supercompression scheme should now be ZSTD
+        int scAfter = t.getSupercompressionScheme();
+        assertEquals(KtxSupercmpScheme.ZSTD, scAfter);
+
+        t.destroy();
+    }
+
+    @Test
+    public void testSupercompressionZLIB() throws IOException {
+
+        int sizeX = 32;
+        int sizeY = 32;
+
+        // Create a dummy texture
+        KtxTextureCreateInfo info = new KtxTextureCreateInfo();
+        info.setBaseWidth(sizeX);
+        info.setBaseHeight(sizeY);
+        info.setVkFormat(VkFormat.VK_FORMAT_R8G8B8A8_SRGB);
+        KtxTexture2 t = KtxTexture2.create(info, KtxTextureCreateStorage.ALLOC_STORAGE);
+        byte[] rgba = new byte[sizeX * sizeY * 4];
+        t.setImageFromMemory(0, 0, 0, rgba);
+
+        // Apply default UASTC compression
+        KtxBasisParams p = new KtxBasisParams();
+        p.setUastc(true);
+        t.compressBasisEx(p);
+
+        // The supercompression scheme should be NONE here
+        int scBefore = t.getSupercompressionScheme();
+        assertEquals(KtxSupercmpScheme.NONE, scBefore);
+
+        // Apply ZLIB compression
+        t.deflateZLIB(10);
+
+        // The supercompression scheme should now be ZLIB
+        int scAfter = t.getSupercompressionScheme();
+        assertEquals(KtxSupercmpScheme.ZLIB, scAfter);
+
+        t.destroy();
+    }
+}
diff --git a/lib/strings.c b/lib/strings.c
index 836f645d86..17a0b5d71e 100644
--- a/lib/strings.c
+++ b/lib/strings.c
@@ -58,7 +58,7 @@ typedef int errorStrings_SIZE_ASSERT[sizeof(errorStrings) / sizeof(char*) - 1 ==
  */
 const char* ktxErrorString(KTX_error_code error)
 {
-    if (error > KTX_ERROR_MAX_ENUM)
+    if (error < 0 || error > KTX_ERROR_MAX_ENUM)
         return "Unrecognized error code";
     return errorStrings[error];
 }