diff --git a/tsvm_core/src/net/torvald/tsvm/GraphicsJSR223Delegate.kt b/tsvm_core/src/net/torvald/tsvm/GraphicsJSR223Delegate.kt
index 5137382..53414dc 100644
--- a/tsvm_core/src/net/torvald/tsvm/GraphicsJSR223Delegate.kt
+++ b/tsvm_core/src/net/torvald/tsvm/GraphicsJSR223Delegate.kt
@@ -4235,14 +4235,14 @@ class GraphicsJSR223Delegate(private val vm: VM) {
         return subbands
     }
 
-    var ANISOTROPY_MULT = floatArrayOf(2.0f, 1.8f, 1.6f, 1.4f, 1.2f, 1.0f)
-    var ANISOTROPY_BIAS = floatArrayOf(0.4f, 0.2f, 0.1f, 0.0f, 0.0f, 0.0f)
-    var ANISOTROPY_MULT_CHROMA = floatArrayOf(6.6f, 5.5f, 4.4f, 3.3f, 2.2f, 1.1f)
-    var ANISOTROPY_BIAS_CHROMA = floatArrayOf(1.0f, 0.8f, 0.6f, 0.4f, 0.2f, 0.0f)
+    var ANISOTROPY_MULT = floatArrayOf(2.0f, 1.8f, 1.6f, 1.4f, 1.2f, 1.0f, 1.0f)
+    var ANISOTROPY_BIAS = floatArrayOf(0.4f, 0.2f, 0.1f, 0.0f, 0.0f, 0.0f, 0.0f)
+    var ANISOTROPY_MULT_CHROMA = floatArrayOf(6.6f, 5.5f, 4.4f, 3.3f, 2.2f, 1.1f, 1.0f)
+    var ANISOTROPY_BIAS_CHROMA = floatArrayOf(1.0f, 0.8f, 0.6f, 0.4f, 0.2f, 0.0f, 0.0f)
 
 
 
-    private fun perceptual_model3_LH(quality: Int, level: Float): Float {
+    private fun perceptual_model3_LH(level: Float): Float {
         val H4 = 1.2f
         val Q = 2f // using fixed value for fixed curve; quantiser will scale it up anyway
         val Q12 = Q * 12f
@@ -4268,9 +4268,9 @@ class GraphicsJSR223Delegate(private val vm: VM) {
         return lerp(LH, HL, Kx)
     }
 
-    fun perceptual_model3_LL(quality: Int, level: Float): Float {
-        val n = perceptual_model3_LH(quality, level)
-        val m = perceptual_model3_LH(quality, level - 1) / n
+    fun perceptual_model3_LL(level: Float): Float {
+        val n = perceptual_model3_LH(level)
+        val m = perceptual_model3_LH(level - 1) / n
 
         return n / m
     }
@@ -4284,13 +4284,13 @@ class GraphicsJSR223Delegate(private val vm: VM) {
 
     private fun tavDeriveEncoderQindex(qIndex: Int, qYGlobal: Int): Int {
         if (qIndex > 0) return qIndex - 1
-        return if (qYGlobal >= 60) 0
-        else if (qYGlobal >= 42) 1
-        else if (qYGlobal >= 25) 2
-        else if (qYGlobal >= 12) 3
-        else if (qYGlobal >= 6) 4
+        return if (qYGlobal >= 79) 0
+        else if (qYGlobal >= 47) 1
+        else if (qYGlobal >= 23) 2
+        else if (qYGlobal >= 11) 3
+        else if (qYGlobal >= 5) 4
         else if (qYGlobal >= 2) 5
-        else 5
+        else 6
     }
 
     // level is one-based index
@@ -4306,10 +4306,10 @@ class GraphicsJSR223Delegate(private val vm: VM) {
             // LUMA CHANNEL: Based on statistical analysis from real video content
             
             // LL subband - contains most image energy, preserve carefully
-            if (subbandType == 0) return perceptual_model3_LL(qualityLevel, level)
+            if (subbandType == 0) return perceptual_model3_LL(level)
             
             // LH subband - horizontal details (human eyes more sensitive)
-            val LH: Float = perceptual_model3_LH(qualityLevel, level)
+            val LH: Float = perceptual_model3_LH(level)
             if (subbandType == 1) return LH
             
             // HL subband - vertical details
diff --git a/video_encoder/encoder_tav.c b/video_encoder/encoder_tav.c
index f06d528..66371a0 100644
--- a/video_encoder/encoder_tav.c
+++ b/video_encoder/encoder_tav.c
@@ -181,14 +181,14 @@ static const int QLUT[] = {1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21
 
 // Quality level to quantisation mapping for different channels
 // the values are indices to the QLUT
-static const int QUALITY_Y[] = {79, 47, 23, 11, 5, 2, 0}; // 96, 48, 24, 12, 6, 3, 1
+static const int QUALITY_Y[] = {79, 47, 23, 11, 5, 2, 1}; // 96, 48, 24, 12, 6, 3, 2
 static const int QUALITY_CO[] = {123, 108, 91, 76, 59, 29, 4}; // 240, 180, 120, 90, 60, 30, 5
 static const int QUALITY_CG[] = {148, 133, 113, 99, 76, 39, 7}; // 424, 304, 200, 144, 90, 40, 8
-static const int QUALITY_ALPHA[] = {79, 47, 23, 11, 5, 2, 0}; // 96, 48, 24, 12, 6, 3, 1
+static const int QUALITY_ALPHA[] = {79, 47, 23, 11, 5, 2, 1}; // 96, 48, 24, 12, 6, 3, 2
 
 // Dead-zone quantisation thresholds per quality level
 // Higher values = more aggressive (more coefficients set to zero)
-static const float DEAD_ZONE_THRESHOLD[] = {2.0f, 1.8f, 1.6f, 1.4f, 1.2f, 1.0f, 0.0f};
+static const float DEAD_ZONE_THRESHOLD[] = {1.5f, 1.5f, 1.2f, 1.0f, 0.8f, 0.6f, 0.0f};
 
 // Dead-zone scaling factors for different subband levels
 #define DEAD_ZONE_FINEST_SCALE 1.0f      // Full dead-zone for finest level (level 6)
diff --git a/video_encoder/visualise_coefficients.c b/video_encoder/visualise_coefficients.c
index a9c4ec5..8f171bf 100644
--- a/video_encoder/visualise_coefficients.c
+++ b/video_encoder/visualise_coefficients.c
@@ -104,10 +104,11 @@ int main(int argc, char *argv[]) {
         return 1;
     }
 
-    // Analyse coefficient distribution
+    // Analyse coefficient distribution - Overall and per-subband
     size_t zeros = 0, positives = 0, negatives = 0;
     int16_t min_val = INT16_MAX, max_val = INT16_MIN;
 
+    // Calculate overall statistics
     for (size_t i = 0; i < expected_count; i++) {
         if (coeffs[i] == 0) zeros++;
         else if (coeffs[i] > 0) positives++;
@@ -117,12 +118,109 @@ int main(int argc, char *argv[]) {
         if (coeffs[i] > max_val) max_val = coeffs[i];
     }
 
-    printf("Coefficient statistics:\n");
+    printf("Overall coefficient statistics:\n");
     printf("  Total: %zu\n", expected_count);
     printf("  Zeros: %zu (%.1f%%)\n", zeros, 100.0 * zeros / expected_count);
     printf("  Positives: %zu (%.1f%%)\n", positives, 100.0 * positives / expected_count);
     printf("  Negatives: %zu (%.1f%%)\n", negatives, 100.0 * negatives / expected_count);
-    printf("  Range: [%d, %d]\n", min_val, max_val);
+    printf("  Range: [%d, %d]\n\n", min_val, max_val);
+
+    // Per-subband statistics
+    // Linear layout: [LL1, LH1, HL1, HH1, LH2, HL2, HH2, ..., LH6, HL6, HH6]
+    size_t offset = 0;
+
+    // Determine number of DWT levels (assuming standard 6-level for 560x448)
+    int num_levels = 6;
+    int w = width, h = height;
+
+    // LL subband (deepest level, smallest)
+    int ll_divisor = 1 << num_levels;  // 2^6 = 64
+    int ll_w = w / ll_divisor;
+    int ll_h = h / ll_divisor;
+    size_t ll_size = ll_w * ll_h;
+
+    if (offset + ll_size <= expected_count) {
+        size_t ll_zeros = 0, ll_pos = 0, ll_neg = 0;
+        int16_t ll_min = INT16_MAX, ll_max = INT16_MIN;
+
+        for (size_t i = 0; i < ll_size; i++) {
+            int16_t val = coeffs[offset + i];
+            if (val == 0) ll_zeros++;
+            else if (val > 0) ll_pos++;
+            else ll_neg++;
+            if (val < ll_min) ll_min = val;
+            if (val > ll_max) ll_max = val;
+        }
+
+        printf("LL%d subband:\n", num_levels);
+        printf("  Total: %zu\n", ll_size);
+        printf("  Zeros: %zu (%.1f%%)\n", ll_zeros, 100.0 * ll_zeros / ll_size);
+        printf("  Positives: %zu (%.1f%%)\n", ll_pos, 100.0 * ll_pos / ll_size);
+        printf("  Negatives: %zu (%.1f%%)\n", ll_neg, 100.0 * ll_neg / ll_size);
+        printf("  Range: [%d, %d]\n\n", ll_min, ll_max);
+
+        offset += ll_size;
+    }
+
+    // LH, HL, HH subbands for each level (from deepest to finest)
+    for (int level = num_levels; level >= 1; level--) {
+        int divisor = 1 << level;  // 2^level
+        int sub_w = w / divisor;
+        int sub_h = h / divisor;
+        size_t sub_size = sub_w * sub_h;
+
+        if (offset + 3 * sub_size > expected_count) break;
+
+        // LH subband
+        size_t lh_zeros = 0, lh_pos = 0, lh_neg = 0;
+        int16_t lh_min = INT16_MAX, lh_max = INT16_MIN;
+        for (size_t i = 0; i < sub_size; i++) {
+            int16_t val = coeffs[offset + i];
+            if (val == 0) lh_zeros++;
+            else if (val > 0) lh_pos++;
+            else lh_neg++;
+            if (val < lh_min) lh_min = val;
+            if (val > lh_max) lh_max = val;
+        }
+        offset += sub_size;
+
+        // HL subband
+        size_t hl_zeros = 0, hl_pos = 0, hl_neg = 0;
+        int16_t hl_min = INT16_MAX, hl_max = INT16_MIN;
+        for (size_t i = 0; i < sub_size; i++) {
+            int16_t val = coeffs[offset + i];
+            if (val == 0) hl_zeros++;
+            else if (val > 0) hl_pos++;
+            else hl_neg++;
+            if (val < hl_min) hl_min = val;
+            if (val > hl_max) hl_max = val;
+        }
+        offset += sub_size;
+
+        // HH subband
+        size_t hh_zeros = 0, hh_pos = 0, hh_neg = 0;
+        int16_t hh_min = INT16_MAX, hh_max = INT16_MIN;
+        for (size_t i = 0; i < sub_size; i++) {
+            int16_t val = coeffs[offset + i];
+            if (val == 0) hh_zeros++;
+            else if (val > 0) hh_pos++;
+            else hh_neg++;
+            if (val < hh_min) hh_min = val;
+            if (val > hh_max) hh_max = val;
+        }
+        offset += sub_size;
+
+        printf("Level %d subbands (%dx%d each):\n", level, sub_w, sub_h);
+        printf("  LH%d: Total=%zu, Zeros=%zu (%.1f%%), Pos=%zu (%.1f%%), Neg=%zu (%.1f%%), Range=[%d,%d]\n",
+               level, sub_size, lh_zeros, 100.0*lh_zeros/sub_size,
+               lh_pos, 100.0*lh_pos/sub_size, lh_neg, 100.0*lh_neg/sub_size, lh_min, lh_max);
+        printf("  HL%d: Total=%zu, Zeros=%zu (%.1f%%), Pos=%zu (%.1f%%), Neg=%zu (%.1f%%), Range=[%d,%d]\n",
+               level, sub_size, hl_zeros, 100.0*hl_zeros/sub_size,
+               hl_pos, 100.0*hl_pos/sub_size, hl_neg, 100.0*hl_neg/sub_size, hl_min, hl_max);
+        printf("  HH%d: Total=%zu, Zeros=%zu (%.1f%%), Pos=%zu (%.1f%%), Neg=%zu (%.1f%%), Range=[%d,%d]\n\n",
+               level, sub_size, hh_zeros, 100.0*hh_zeros/sub_size,
+               hh_pos, 100.0*hh_pos/sub_size, hh_neg, 100.0*hh_neg/sub_size, hh_min, hh_max);
+    }
 
     // Write PPM image
     FILE *fp_out = fopen(output_file, "wb");