From c16ea160b709d052320236005472befce2275c37 Mon Sep 17 00:00:00 2001
From: Lee Salzman <lsalzman@gmail.com>
Date: Sun, 23 May 2010 06:58:05 +0000
Subject: [PATCH] range coder cleanups

git-svn-id: svn://svn.code.sf.net/p/actiongame/code/trunk/ac@5004 e016b1c5-ed68-44aa-a2f7-31cac88cffde
---
 source/enet/compress.c | 319 +++++++++++++++++++++++------------------
 source/lib/enet.lib    | Bin 41120 -> 42476 bytes
 2 files changed, 180 insertions(+), 139 deletions(-)

diff --git a/source/enet/compress.c b/source/enet/compress.c
index 07f159e0..e8726648 100644
--- a/source/enet/compress.c
+++ b/source/enet/compress.c
@@ -1,6 +1,6 @@
 /** 
  @file compress.c
- @brief An order-1 adaptive range coder
+ @brief An order-2 adaptive range coder
 */
 #define ENET_BUILDING_LIB 1
 #include <string.h>
@@ -8,18 +8,18 @@
 
 typedef struct _ENetSymbol
 {
+    /* binary indexed tree of symbols */
     enet_uint8 value;
     enet_uint8 count;
-    enet_uint16 total;
+    enet_uint16 under;
     enet_uint16 left, right;
-} ENetSymbol;
 
-typedef struct _ENetPredictor
-{
+    /* context defined by this symbol */
+    enet_uint16 symbols;
     enet_uint16 escapes;
     enet_uint16 total;
-    ENetSymbol *symbols;
-} ENetPredictor;
+    enet_uint16 parent; 
+} ENetSymbol;
 
 enum
 {
@@ -30,14 +30,15 @@ enum
     ENET_CONTEXT_SYMBOL_MINIMUM = 1,
     ENET_CONTEXT_ESCAPE_MINIMUM = 1,
 
+    ENET_SUBCONTEXT_ORDER = 2,
     ENET_SUBCONTEXT_SYMBOL_DELTA = 2,
-    ENET_SUBCONTEXT_ESCAPE_DELTA = 3
+    ENET_SUBCONTEXT_ESCAPE_DELTA = 5
 };
 
 typedef struct _ENetRangeCoder
 {
-    ENetPredictor context, subcontexts[256];
-    ENetSymbol symbols[256 + ENET_PROTOCOL_MAXIMUM_MTU + 1];
+    /* only allocate enough symbols for reasonable MTUs */
+    ENetSymbol symbols[4096];
 } ENetRangeCoder;
 
 void *
@@ -60,21 +61,26 @@ enet_range_coder_destroy (void * context)
     enet_free (rangeCoder);
 }
 
-#define ENET_PREDICTOR_CREATE(predictor, escapes_, minimum) \
-{ \
-    (predictor).escapes = escapes_; \
-    (predictor).total = escapes_ + 256*minimum; \
-    (predictor).symbols = NULL; \
-}
-
 #define ENET_SYMBOL_CREATE(symbol, value_, count_) \
 { \
     symbol = & rangeCoder -> symbols [nextSymbol ++]; \
     symbol -> value = value_; \
     symbol -> count = count_; \
-    symbol -> total = count_; \
+    symbol -> under = count_; \
     symbol -> left = 0; \
     symbol -> right = 0; \
+    symbol -> symbols = 0; \
+    symbol -> escapes = 0; \
+    symbol -> total = 0; \
+    symbol -> parent = 0; \
+}
+
+#define ENET_CONTEXT_CREATE(context, escapes_, minimum) \
+{ \
+    ENET_SYMBOL_CREATE (context, 0, 0); \
+    (context) -> escapes = escapes_; \
+    (context) -> total = escapes_ + 256*minimum; \
+    (context) -> symbols = 0; \
 }
 
 static enet_uint16
@@ -84,21 +90,21 @@ enet_symbol_rescale (ENetSymbol * symbol)
     for (;;)
     {
         symbol -> count -= symbol->count >> 1;
-        symbol -> total = symbol -> count;
+        symbol -> under = symbol -> count;
         if (symbol -> left)
-          symbol -> total += enet_symbol_rescale (symbol + symbol -> left);
-        total += symbol -> total;
+          symbol -> under += enet_symbol_rescale (symbol + symbol -> left);
+        total += symbol -> under;
         if (! symbol -> right) break;
         symbol += symbol -> right;
     } 
     return total;
 }
 
-#define ENET_PREDICTOR_RESCALE(predictor, minimum) \
+#define ENET_CONTEXT_RESCALE(context, minimum) \
 { \
-    (predictor).total = (predictor).symbols != NULL ? enet_symbol_rescale ((predictor).symbols) : 0; \
-    (predictor).escapes -= (predictor).escapes >> 1; \
-    (predictor).total += (predictor).escapes + 256*minimum; \
+    (context) -> total = (context) -> symbols ? enet_symbol_rescale ((context) + (context) -> symbols) : 0; \
+    (context) -> escapes -= (context) -> escapes >> 1; \
+    (context) -> total += (context) -> escapes + 256*minimum; \
 }
 
 #define ENET_RANGE_CODER_OUTPUT(value) \
@@ -137,48 +143,55 @@ enet_symbol_rescale (ENetSymbol * symbol)
 
 #define ENET_RANGE_CODER_FREE_SYMBOLS \
 { \
-    if (nextSymbol + 1 >= sizeof (rangeCoder -> symbols) / sizeof (ENetSymbol)) \
+    if (nextSymbol >= sizeof (rangeCoder -> symbols) / sizeof (ENetSymbol) - ENET_SUBCONTEXT_ORDER) \
     { \
-        ENET_PREDICTOR_CREATE (rangeCoder -> context, ENET_CONTEXT_ESCAPE_MINIMUM, ENET_CONTEXT_SYMBOL_MINIMUM); \
-        subcontext = NULL; \
         nextSymbol = 0; \
+        ENET_CONTEXT_CREATE (root, ENET_CONTEXT_ESCAPE_MINIMUM, ENET_CONTEXT_SYMBOL_MINIMUM); \
+        predicted = 0; \
+        order = 0; \
     } \
 }
 
-#define ENET_PREDICTOR_ENCODE(predictor, value_, under_, count_, update) \
+#define ENET_CONTEXT_ENCODE(context, symbol_, value_, under_, count_, update) \
 { \
+    ENetSymbol * child; \
     under_ = 0; \
     count_ = 0; \
-    if ((predictor).symbols == NULL) \
+    if (! (context) -> symbols) \
     { \
-        ENET_SYMBOL_CREATE ((predictor).symbols, value_, update); \
+        ENET_SYMBOL_CREATE (child, value_, update); \
+        (context) -> symbols = child - (context); \
+        symbol_ = child; \
     } \
     else \
     { \
-        ENetSymbol * symbol = (predictor).symbols, * child; \
+        ENetSymbol * node = (context) + (context) -> symbols; \
         for (;;) \
         { \
-            if (value_ < symbol -> value) \
+            if (value_ < node -> value) \
             { \
-                symbol -> total += update; \
-                if (symbol -> left) { symbol += symbol -> left; continue; } \
+                node -> under += update; \
+                if (node -> left) { node += node -> left; continue; } \
                 ENET_SYMBOL_CREATE (child, value_, update); \
-                symbol -> left = child - symbol; \
+                node -> left = child - node; \
+                symbol_ = child; \
             } \
             else \
-            if (value_ > symbol -> value) \
+            if (value_ > node -> value) \
             { \
-                under_ += symbol -> total; \
-                if (symbol -> right) { symbol += symbol -> right; continue; } \
+                under_ += node -> under; \
+                if (node -> right) { node += node -> right; continue; } \
                 ENET_SYMBOL_CREATE (child, value_, update); \
-                symbol -> right = child - symbol; \
+                node -> right = child - node; \
+                symbol_ = child; \
             } \
             else \
             { \
-                count_ = symbol -> count; \
-                under_ += symbol -> total - count_; \
-                symbol -> total += update; \
-                symbol -> count += update; \
+                count_ = node -> count; \
+                under_ += node -> under - count_; \
+                node -> under += update; \
+                node -> count += update; \
+                symbol_ = node; \
             } \
             break; \
         } \
@@ -192,8 +205,9 @@ enet_range_coder_compress (void * context, const ENetBuffer * inBuffers, size_t
     enet_uint8 * outStart = outData, * outEnd = & outData [outLimit];
     const enet_uint8 * inData, * inEnd;
     enet_uint32 encodeLow = 0, encodeRange = ~0;
-    ENetPredictor * subcontext = NULL;
-    size_t nextSymbol = 0;
+    ENetSymbol * root;
+    enet_uint16 predicted = 0;
+    size_t order = 0, nextSymbol = 0;
 
     if (rangeCoder == NULL || inBufferCount <= 0 || inLimit <= 0)
       return 0;
@@ -203,12 +217,14 @@ enet_range_coder_compress (void * context, const ENetBuffer * inBuffers, size_t
     inBuffers ++;
     inBufferCount --;
 
-    ENET_PREDICTOR_CREATE (rangeCoder -> context, ENET_CONTEXT_ESCAPE_MINIMUM, ENET_CONTEXT_SYMBOL_MINIMUM);
+    ENET_CONTEXT_CREATE (root, ENET_CONTEXT_ESCAPE_MINIMUM, ENET_CONTEXT_SYMBOL_MINIMUM);
 
     for (;;)
     {
+        ENetSymbol * subcontext, * symbol;
         enet_uint8 value;
-        enet_uint16 under, count;
+        enet_uint16 under, count, * parent = & predicted;
+        size_t level = order;
         if (inData >= inEnd)
         {
             if (inBufferCount <= 0)
@@ -220,9 +236,13 @@ enet_range_coder_compress (void * context, const ENetBuffer * inBuffers, size_t
         }
         value = * inData ++;
 
-        if (subcontext != NULL)
+        for (subcontext = & rangeCoder -> symbols [predicted]; 
+             subcontext != root; 
+             subcontext = & rangeCoder -> symbols [subcontext -> parent])
         {
-            ENET_PREDICTOR_ENCODE (* subcontext, value, under, count, ENET_SUBCONTEXT_SYMBOL_DELTA);
+            ENET_CONTEXT_ENCODE (subcontext, symbol, value, under, count, ENET_SUBCONTEXT_SYMBOL_DELTA);
+            * parent = symbol - rangeCoder -> symbols;
+            parent = & symbol -> parent;
             if (count > 0)
             {
                 ENET_RANGE_CODER_ENCODE (subcontext -> escapes + under, count, subcontext -> total);
@@ -230,29 +250,29 @@ enet_range_coder_compress (void * context, const ENetBuffer * inBuffers, size_t
             else
             {
                 if (subcontext -> escapes > 0)
-                  ENET_RANGE_CODER_ENCODE (0, subcontext -> escapes, subcontext -> total);
+                    ENET_RANGE_CODER_ENCODE (0, subcontext -> escapes, subcontext -> total);
                 subcontext -> escapes += ENET_SUBCONTEXT_ESCAPE_DELTA;
                 subcontext -> total += ENET_SUBCONTEXT_ESCAPE_DELTA;
             }
             subcontext -> total += ENET_SUBCONTEXT_SYMBOL_DELTA;
             if (count > 0xFF - 2*ENET_SUBCONTEXT_SYMBOL_DELTA || subcontext -> total > ENET_RANGE_CODER_BOTTOM - 0x100)
-              ENET_PREDICTOR_RESCALE (* subcontext, 0);
-            if (count <= 0)
-              goto parentContext;
-        }
-        else
-        {
-        parentContext:
-            ENET_PREDICTOR_ENCODE (rangeCoder -> context, value, under, count, ENET_CONTEXT_SYMBOL_DELTA);
-            if (count <= 0)
-              ENET_PREDICTOR_CREATE (rangeCoder -> subcontexts [value], 0, 0);
-            ENET_RANGE_CODER_ENCODE (rangeCoder -> context.escapes + under + value*ENET_CONTEXT_SYMBOL_MINIMUM, count + ENET_CONTEXT_SYMBOL_MINIMUM, rangeCoder -> context.total);
-            rangeCoder -> context.total += ENET_CONTEXT_SYMBOL_DELTA; 
-            if (count > 0xFF - 2*ENET_CONTEXT_SYMBOL_DELTA || rangeCoder -> context.total > ENET_RANGE_CODER_BOTTOM - 0x100)
-              ENET_PREDICTOR_RESCALE (rangeCoder -> context, ENET_CONTEXT_SYMBOL_MINIMUM);
+              ENET_CONTEXT_RESCALE (subcontext, 0);
+            if (count > 0) goto nextInput;
         }
 
-        subcontext = & rangeCoder -> subcontexts [value];
+        ENET_CONTEXT_ENCODE (root, symbol, value, under, count, ENET_CONTEXT_SYMBOL_DELTA);
+        * parent = symbol - rangeCoder -> symbols;
+        parent = & symbol -> parent;
+        ENET_RANGE_CODER_ENCODE (root -> escapes + under + value*ENET_CONTEXT_SYMBOL_MINIMUM, count + ENET_CONTEXT_SYMBOL_MINIMUM, root -> total);
+        root -> total += ENET_CONTEXT_SYMBOL_DELTA; 
+        if (count > 0xFF - 2*ENET_CONTEXT_SYMBOL_DELTA || root -> total > ENET_RANGE_CODER_BOTTOM - 0x100)
+          ENET_CONTEXT_RESCALE (root, ENET_CONTEXT_SYMBOL_MINIMUM);
+
+    nextInput:
+        if (order >= ENET_SUBCONTEXT_ORDER) 
+          predicted = rangeCoder -> symbols [predicted].parent;
+        else 
+          order ++;
         ENET_RANGE_CODER_FREE_SYMBOLS;
     }
 
@@ -290,84 +310,91 @@ enet_range_coder_compress (void * context, const ENetBuffer * inBuffers, size_t
     } \
 }
 
-#define ENET_PREDICTOR_TRY_DECODE(predictor, code, value_, under_, count_, update) \
+#define ENET_CONTEXT_TRY_DECODE(context, symbol_, code, value_, under_, count_, update) \
 { \
     under_ = 0; \
     count_ = 0; \
-    if ((predictor).symbols == NULL) \
+    if (! (context) -> symbols) \
       return 0; \
     else \
     { \
-        ENetSymbol * symbol = (predictor).symbols; \
+        ENetSymbol * node = (context) + (context) -> symbols; \
         for (;;) \
         { \
-            if (code >= under_ + symbol -> total) \
+            if (code >= under_ + node -> under) \
             { \
-                under_ += symbol -> total; \
-                if (! symbol -> right) return 0; \
-                symbol += symbol -> right; \
+                under_ += node -> under; \
+                if (! node -> right) return 0; \
+                node += node -> right; \
             } \
             else \
-            if (code < under_ + symbol -> total - symbol -> count) \
+            if (code < under_ + node -> under - node -> count) \
             { \
-                symbol -> total += update; \
-                if (! symbol -> left) return 0; \
-                symbol += symbol -> left; \
+                node -> under += update; \
+                if (! node -> left) return 0; \
+                node += node -> left; \
             } \
             else \
             { \
-                value_ = symbol -> value; \
-                count_ = symbol -> count; \
-                under_ += symbol -> total - count_; \
-                symbol -> total += update; \
-                symbol -> count += update; \
+                value_ = node -> value; \
+                count_ = node -> count; \
+                under_ += node -> under - count_; \
+                node -> under += update; \
+                node -> count += update; \
+                symbol_ = node; \
                 break; \
             } \
         } \
     } \
 }
 
-#define ENET_PREDICTOR_DECODE(predictor, code, value_, under_, count_, update, minimum) \
+#define ENET_CONTEXT_DECODE(context, symbol_, code, value_, under_, count_, update, minimum) \
 { \
+    ENetSymbol * child; \
     int lowValue = -1; \
     under_ = 0; \
     count_ = 0; \
-    if ((predictor).symbols == NULL) \
+    if (! (context) -> symbols) \
     { \
         value_ = code / minimum; \
-        ENET_SYMBOL_CREATE ((predictor).symbols, value_, update); \
+        ENET_SYMBOL_CREATE (child, value_, update); \
+        (context) -> symbols = child - (context); \
+        symbol_ = child; \
     } \
     else \
     { \
-        ENetSymbol * symbol = (predictor).symbols, * child; \
+        ENetSymbol * node = (context) + (context) -> symbols; \
         for (;;) \
         { \
-            enet_uint16 total = under_ + symbol -> total + (symbol -> value + 1)*minimum; \
+            enet_uint16 total = under_ + node -> under + (node -> value + 1)*minimum; \
             if (code >= total) \
             { \
-                under_ += symbol -> total; \
-                lowValue = symbol -> value; \
-                if (symbol -> right) { symbol += symbol -> right; continue; } \
+                under_ += node -> under; \
+                lowValue = node -> value; \
+                if (node -> right) { node += node -> right; continue; } \
                 value_ = lowValue + 1 + (code - under_ - (lowValue + 1)*minimum) / minimum; \
                 ENET_SYMBOL_CREATE (child, value_, update); \
-                symbol -> right = child - symbol; \
+                node -> right = child - node; \
+                symbol_ = child; \
             } \
             else \
-            if (code < total - symbol -> count - minimum) \
+            if (code < total - node -> count - minimum) \
             { \
-                symbol -> total += update; \
-                if (symbol -> left) { symbol += symbol -> left; continue; } \
+                node -> under += update; \
+                if (node -> left) { node += node -> left; continue; } \
                 value_ = lowValue + 1 + (code - under_ - (lowValue + 1)*minimum) / minimum; \
                 ENET_SYMBOL_CREATE (child, value_, update); \
-                symbol -> left = child - symbol; \
+                node -> left = child - node; \
+                symbol_ = child; \
             } \
             else \
             { \
-                value_ = symbol -> value; \
-                count_ = symbol -> count; \
-                under_ += symbol -> total - count_; \
-                symbol -> total += update; \
-                symbol -> count += update; \
+                value_ = node -> value; \
+                count_ = node -> count; \
+                under_ += node -> under - count_; \
+                node -> under += update; \
+                node -> count += update; \
+                symbol_ = node; \
             } \
             break; \
         } \
@@ -381,70 +408,84 @@ enet_range_coder_decompress (void * context, const enet_uint8 * inData, size_t i
     enet_uint8 * outStart = outData, * outEnd = & outData [outLimit];
     const enet_uint8 * inEnd = & inData [inLimit];
     enet_uint32 decodeLow = 0, decodeCode = 0, decodeRange = ~0;
-    ENetPredictor * subcontext = NULL;
-    size_t nextSymbol = 0;
+    ENetSymbol * root;
+    enet_uint16 predicted = 0;
+    size_t order = 0, nextSymbol = 0;
 
     if (rangeCoder == NULL || inLimit <= 0)
       return 0;
 
-    ENET_PREDICTOR_CREATE (rangeCoder -> context, ENET_CONTEXT_ESCAPE_MINIMUM, ENET_CONTEXT_SYMBOL_MINIMUM);
+    ENET_CONTEXT_CREATE (root, ENET_CONTEXT_ESCAPE_MINIMUM, ENET_CONTEXT_SYMBOL_MINIMUM);
 
     ENET_RANGE_CODER_SEED;
 
     for (;;)
     {
+        ENetSymbol * subcontext, * symbol, * patch;
         enet_uint8 value = 0;
-        enet_uint16 code, under, count;
-        if (subcontext != NULL && subcontext -> escapes > 0)
+        enet_uint16 code, under, count, bottom, * parent = & predicted;
+
+        for (subcontext = & rangeCoder -> symbols [predicted];
+             subcontext != root;
+             subcontext = & rangeCoder -> symbols [subcontext -> parent])
         {
+            if (subcontext -> escapes <= 0)
+              continue;
             code = ENET_RANGE_CODER_READ (subcontext -> total);
-            if (code < subcontext -> escapes)
+            if (code < subcontext -> escapes) 
             {
                 ENET_RANGE_CODER_DECODE (0, subcontext -> escapes, subcontext -> total);
-                goto parentContext;
+                continue;
             }
             code -= subcontext -> escapes;
-            ENET_PREDICTOR_TRY_DECODE (* subcontext, code, value, under, count, ENET_SUBCONTEXT_SYMBOL_DELTA);
+            ENET_CONTEXT_TRY_DECODE (subcontext, symbol, code, value, under, count, ENET_SUBCONTEXT_SYMBOL_DELTA);
+            bottom = symbol - rangeCoder -> symbols;
             ENET_RANGE_CODER_DECODE (subcontext -> escapes + under, count, subcontext -> total);
             subcontext -> total += ENET_SUBCONTEXT_SYMBOL_DELTA;
             if (count > 0xFF - 2*ENET_SUBCONTEXT_SYMBOL_DELTA || subcontext -> total > ENET_RANGE_CODER_BOTTOM - 0x100)
-              ENET_PREDICTOR_RESCALE (* subcontext, 0);
+              ENET_CONTEXT_RESCALE (subcontext, 0);
+            goto patchContexts;
         }
-        else
+
+        code = ENET_RANGE_CODER_READ (root -> total);
+        if (code < root -> escapes)
         {
-        parentContext:
-            code = ENET_RANGE_CODER_READ (rangeCoder -> context.total);
-            if (code < rangeCoder -> context.escapes)
-            {
-                ENET_RANGE_CODER_DECODE (0, rangeCoder -> context.escapes, rangeCoder -> context.total);
-                break;
-            }
-            code -= rangeCoder -> context.escapes;
-            ENET_PREDICTOR_DECODE (rangeCoder -> context, code, value, under, count, ENET_CONTEXT_SYMBOL_DELTA, ENET_CONTEXT_SYMBOL_MINIMUM);
-            if (count <= 0)
-              ENET_PREDICTOR_CREATE (rangeCoder -> subcontexts [value], 0, 0);
-            ENET_RANGE_CODER_DECODE (rangeCoder -> context.escapes + under + value*ENET_CONTEXT_SYMBOL_MINIMUM, count + ENET_CONTEXT_SYMBOL_MINIMUM, rangeCoder -> context.total);
-            rangeCoder -> context.total += ENET_CONTEXT_SYMBOL_DELTA;
-            if (count > 0xFF - 2*ENET_CONTEXT_SYMBOL_DELTA || rangeCoder -> context.total > ENET_RANGE_CODER_BOTTOM - 0x100)
-              ENET_PREDICTOR_RESCALE (rangeCoder -> context, ENET_CONTEXT_SYMBOL_MINIMUM);
-            if (subcontext != NULL)
-            {
-                enet_uint16 under, count;
-                ENET_PREDICTOR_ENCODE (* subcontext, value, under, count, ENET_SUBCONTEXT_SYMBOL_DELTA);
-                if (count <= 0)
-                {
-                    subcontext -> escapes += ENET_SUBCONTEXT_ESCAPE_DELTA;
-                    subcontext -> total += ENET_SUBCONTEXT_ESCAPE_DELTA;
-                }
-                subcontext -> total += ENET_SUBCONTEXT_SYMBOL_DELTA; 
-                if (count > 0xFF - 2*ENET_SUBCONTEXT_SYMBOL_DELTA || subcontext -> total > ENET_RANGE_CODER_BOTTOM - 0x100)
-                  ENET_PREDICTOR_RESCALE (* subcontext, 0);
-            }
+            ENET_RANGE_CODER_DECODE (0, root -> escapes, root -> total);
+            break;
         }
+        code -= root -> escapes;
+        ENET_CONTEXT_DECODE (root, symbol, code, value, under, count, ENET_CONTEXT_SYMBOL_DELTA, ENET_CONTEXT_SYMBOL_MINIMUM);
+        bottom = symbol - rangeCoder -> symbols;
+        ENET_RANGE_CODER_DECODE (root -> escapes + under + value*ENET_CONTEXT_SYMBOL_MINIMUM, count + ENET_CONTEXT_SYMBOL_MINIMUM, root -> total);
+        root -> total += ENET_CONTEXT_SYMBOL_DELTA;
+        if (count > 0xFF - 2*ENET_CONTEXT_SYMBOL_DELTA || root -> total > ENET_RANGE_CODER_BOTTOM - 0x100)
+          ENET_CONTEXT_RESCALE (root, ENET_CONTEXT_SYMBOL_MINIMUM);
+
+    patchContexts:
+        for (patch = & rangeCoder -> symbols [predicted];
+             patch != subcontext;
+             patch = & rangeCoder -> symbols [patch -> parent])
+        {
+            ENET_CONTEXT_ENCODE (patch, symbol, value, under, count, ENET_SUBCONTEXT_SYMBOL_DELTA);
+            * parent = symbol - rangeCoder -> symbols;
+            parent = & symbol -> parent;
+            if (count <= 0)
+            {
+                patch -> escapes += ENET_SUBCONTEXT_ESCAPE_DELTA;
+                patch -> total += ENET_SUBCONTEXT_ESCAPE_DELTA;
+            }
+            patch -> total += ENET_SUBCONTEXT_SYMBOL_DELTA; 
+            if (count > 0xFF - 2*ENET_SUBCONTEXT_SYMBOL_DELTA || patch -> total > ENET_RANGE_CODER_BOTTOM - 0x100)
+              ENET_CONTEXT_RESCALE (patch, 0);
+        }
+        * parent = bottom;
 
         ENET_RANGE_CODER_OUTPUT (value);
 
-        subcontext = & rangeCoder -> subcontexts [value];
+        if (order >= ENET_SUBCONTEXT_ORDER)
+          predicted = rangeCoder -> symbols [predicted].parent;
+        else
+          order ++;
         ENET_RANGE_CODER_FREE_SYMBOLS;
     }
                         
diff --git a/source/lib/enet.lib b/source/lib/enet.lib
index 65685195995c41e95f662dcc1ccc22ed5ca4fea4..20f8c516bf63c8cd74905c1a364e97a6319728aa 100644
GIT binary patch
delta 6182
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

delta 4832
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
J>JR;s{Rfc+<+T6+