diff --git a/libavcodec/Makefile b/libavcodec/Makefile
index 9836b47..85a9e8b 100644
--- a/libavcodec/Makefile
+++ b/libavcodec/Makefile
@@ -117,10 +117,10 @@ OBJS-$(CONFIG_EIGHTBPS_DECODER)        += 8bps.o
 OBJS-$(CONFIG_EIGHTSVX_EXP_DECODER)    += 8svx.o
 OBJS-$(CONFIG_EIGHTSVX_FIB_DECODER)    += 8svx.o
 OBJS-$(CONFIG_ESCAPE124_DECODER)       += escape124.o
-OBJS-$(CONFIG_FFV1_DECODER)            += ffv1.o rangecoder.o
-OBJS-$(CONFIG_FFV1_ENCODER)            += ffv1.o rangecoder.o
-OBJS-$(CONFIG_FFV2_DECODER)            += ffv2.o rangecoder.o
-OBJS-$(CONFIG_FFV2_ENCODER)            += ffv2.o rangecoder.o
+OBJS-$(CONFIG_FFV1_DECODER)            += ffv1.o rangecoder.o cabgt.o
+OBJS-$(CONFIG_FFV1_ENCODER)            += ffv1.o rangecoder.o cabgt.o
+OBJS-$(CONFIG_FFV2_DECODER)            += ffv2.o rangecoder.o cabgt.o
+OBJS-$(CONFIG_FFV2_ENCODER)            += ffv2.o rangecoder.o cabgt.o
 OBJS-$(CONFIG_FFVHUFF_DECODER)         += huffyuv.o
 OBJS-$(CONFIG_FFVHUFF_ENCODER)         += huffyuv.o
 OBJS-$(CONFIG_FLAC_DECODER)            += flacdec.o flacdata.o flac.o
diff --git a/libavcodec/bitstream.c b/libavcodec/bitstream.c
index 1e24099..03d70ac 100644
--- a/libavcodec/bitstream.c
+++ b/libavcodec/bitstream.c
@@ -117,13 +117,6 @@ static int alloc_table(VLC *vlc, int size, int use_static)
     return index;
 }
 
-static av_always_inline uint32_t bitswap_32(uint32_t x) {
-    return av_reverse[x&0xFF]<<24
-         | av_reverse[(x>>8)&0xFF]<<16
-         | av_reverse[(x>>16)&0xFF]<<8
-         | av_reverse[x>>24];
-}
-
 typedef struct {
     uint8_t bits;
     uint16_t symbol;
diff --git a/libavcodec/cabgt.c b/libavcodec/cabgt.c
new file mode 100644
index 0000000..b746dd4
--- /dev/null
+++ b/libavcodec/cabgt.c
@@ -0,0 +1,233 @@
+/*
+ * Context Adaptive Binary Group Tester
+ * Copyright (c) 2010 Loren Merritt
+ *
+ * This file is part of FFmpeg.
+ *
+ * FFmpeg is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * FFmpeg is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with FFmpeg; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#include <string.h>
+
+#include "avcodec.h"
+#include "cabgt.h"
+#include "cabgt_data.h"
+#include "bytestream.h"
+
+//FIXME code duplication
+
+static int swizzle_state(int state) {
+    return FFMIN(state, 255-state)<<1 | state>>7;
+}
+
+static void swizzle_states(uint8_t (*dst)[2], const uint8_t *zeros, const uint8_t *ones) {
+    for(int i=0; i<256; i++) {
+        dst[swizzle_state(i)][0] = swizzle_state(zeros[i]);
+        dst[swizzle_state(i)][1] = swizzle_state(ones[i]);
+    }
+}
+
+static void build_cabgt_states(CABGTContext *c, int factor, int max_p){
+    uint8_t zero_state[256] = {0};
+    uint8_t  one_state[256] = {0};
+    const int64_t one= 1LL<<32;
+    int64_t p;
+    int last_p8, p8, i;
+
+    last_p8= 0;
+    p= one/2;
+    for(i=0; i<128; i++){
+        p8= (256*p + one/2) >> 32; //FIXME try without the one
+        if(p8 <= last_p8) p8= last_p8+1;
+        if(last_p8 && last_p8<256 && p8<=max_p)
+            one_state[last_p8]= p8;
+
+        p+= ((one-p)*factor + one/2) >> 32;
+        last_p8= p8;
+    }
+
+    for(i=256-max_p; i<=max_p; i++){
+        if(one_state[i])
+            continue;
+
+        p= (i*one + 128) >> 8;
+        p+= ((one-p)*factor + one/2) >> 32;
+        p8= (256*p + one/2) >> 32; //FIXME try without the one
+        if(p8 <= i) p8= i+1;
+        if(p8 > max_p) p8= max_p;
+        one_state[    i]=     p8;
+    }
+
+    for(i=1; i<255; i++)
+        zero_state[i]= 256-one_state[256-i];
+
+    swizzle_states(c->transition, zero_state, one_state);
+}
+
+static int generate_bits_table(uint8_t *dst, uint8_t *len_table, int size){
+    int len, index;
+    uint32_t bits=1;
+
+    for(len=1; len<=8 && ~bits; len++){
+        for(index=size-1; index>=0; index--){
+            if(len_table[index] == len)
+                dst[index] = bits--;
+        }
+        bits = bits*2+1;
+    }
+    if(~bits){
+        av_log(NULL, AV_LOG_ERROR, "Error generating huffman table\n");
+        return -1;
+    }
+    return 0;
+}
+
+static void alloc_cabgt_common(CABGTContext *c, int encoding){
+    memset(c, 0, sizeof(*c));
+    build_cabgt_states(c, 0.05*(1LL<<32), 256-8);
+    for(int group=0; group<NUM_GROUPS; group++) {
+        uint16_t *codes = c->groups[group].codes;
+        uint8_t *bits = c->groups[group].bits;
+        uint8_t *lens = c->groups[group].lens;
+        int i;
+        for(i=0; i<MAX_CODES && cabgt_tables[group][i][0]; i++) {
+            int len = cabgt_tables[group][i][0];
+            int code = cabgt_tables[group][i][1];
+            if(!encoding)
+                code = ((bitswap_32(code)>>1) | (1<<31)) >> (31-av_log2(code));
+            lens[i] = len;
+            codes[i] = code;
+        }
+        int size = c->groups[group].size = i;
+        generate_bits_table(bits, lens, size);
+        if(encoding) {
+            int max_code = 0;
+            for(i=0; i<size; i++)
+                max_code = FFMAX(max_code, codes[i]);
+            // The inv_codes for group 0 is 32KB, but only a few entries of it are ever checked,
+            // so the cache footprint shouldn't be too bad. Still, it might be worth a special case.
+            c->groups[group].inv_codes = av_malloc(max_code+1);
+            memset(c->groups[group].inv_codes, -1, max_code+1);
+            for(i=0; i<size; i++)
+                c->groups[group].inv_codes[codes[i]] = i;
+        } else {
+            init_vlc_sparse(&c->groups[group].vlc, MAX_VLC_BITS, size, lens, 1, 1, bits, 1, 1, codes, 2, 2, 0);
+        }
+    }
+}
+
+void ff_alloc_cabgt_encoder(CABGTContext *c){
+    alloc_cabgt_common(c, 1);
+}
+
+void ff_alloc_cabgt_decoder(CABGTContext *c){
+    alloc_cabgt_common(c, 0);
+}
+
+void ff_dealloc_cabgt_coder(CABGTContext *c){
+    for(int i=0; i<NUM_GROUPS; i++) {
+        free_vlc(&c->groups[i].vlc);
+        av_freep(&c->groups[i].inv_codes);
+    }
+}
+
+void ff_init_cabgt_encoder(CABGTContext *c, uint8_t *buf, int buf_size){
+    for(int i=0; i<NUM_GROUPS; i++)
+        c->groups[i].buffer_index = 0;
+    c->codes_buffered[0].code = 0;
+    c->buffer_index_old = 1;
+    c->buffer_index_new = 1;
+    init_put_bits(&c->pb, buf, buf_size);
+}
+
+void ff_init_cabgt_decoder(CABGTContext *c, const uint8_t *buf, int buf_size){
+    memset(c->codes_read, 0, sizeof(c->codes_read));
+    init_get_bits(&c->gb, buf, buf_size);
+}
+
+/**
+ *
+ * @return the number of bytes written
+ */
+int ff_cabgt_terminate(CABGTContext *c){
+    int buffer_index = c->buffer_index_old;
+    while(buffer_index != c->buffer_index_new){
+        int group = c->codes_buffered[buffer_index].group;
+        int code = c->codes_buffered[buffer_index].code;
+        int codename = c->codes_buffered[buffer_index].codename;
+        if(code) // FIXME not quite optimal at finding the cheapest extension of the given prefix
+            do {
+                code <<= 1;
+                codename = get_codename(c, group, code);
+            } while(codename < 0);
+        put_bits(&c->pb, c->groups[group].lens[codename], c->groups[group].bits[codename]);
+        buffer_index++;
+        buffer_index &= MAX_BUFFER-1;
+    }
+
+    flush_put_bits(&c->pb);
+    return put_bits_count(&c->pb)/8;
+}
+
+#ifdef TEST
+#define SIZE 10240
+
+#include "libavutil/lfg.h"
+
+int main(void){
+    CABGTContext c;
+    uint8_t b[9*SIZE];
+    uint8_t r[9*SIZE];
+    int i;
+    uint8_t state[10]= {0};
+    AVLFG prng;
+
+    av_lfg_init(&prng, 1);
+
+    ff_alloc_cabgt_encoder(&c);
+    ff_init_cabgt_encoder(&c, b, SIZE);
+
+    memset(state, 255, sizeof(state));
+
+    for(i=0; i<SIZE; i++){
+        r[i] = (av_lfg_get(&prng) % 7) & 1;
+    }
+
+    for(i=0; i<SIZE; i++){
+START_TIMER
+        put_cabgt(&c, state, r[i]);
+STOP_TIMER("put_cabgt")
+    }
+
+    ff_cabgt_terminate(&c);
+    ff_dealloc_cabgt_coder(&c);
+
+    ff_alloc_cabgt_decoder(&c);
+    ff_init_cabgt_decoder(&c, b, SIZE);
+
+    memset(state, 255, sizeof(state));
+
+    for(i=0; i<SIZE; i++){
+START_TIMER
+        if( r[i] != get_cabgt(&c, state) )
+            av_log(NULL, AV_LOG_ERROR, "rac failure at %d\n", i);
+STOP_TIMER("get_cabgt")
+    }
+
+    ff_dealloc_cabgt_coder(&c);
+
+    return 0;
+}
+#endif /* TEST */
diff --git a/libavcodec/cabgt.h b/libavcodec/cabgt.h
new file mode 100644
index 0000000..2d411b8
--- /dev/null
+++ b/libavcodec/cabgt.h
@@ -0,0 +1,136 @@
+/*
+ * Context Adaptive Binary Group Tester
+ * Copyright (c) 2010 Loren Merritt
+ *
+ * This file is part of FFmpeg.
+ *
+ * FFmpeg is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * FFmpeg is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with FFmpeg; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#ifndef AVCODEC_CABGT_H
+#define AVCODEC_CABGT_H
+
+#define DEBUG
+#undef NDEBUG
+
+#include <stdint.h>
+#include <assert.h>
+#include "libavutil/common.h"
+#include "libavutil/internal.h"
+#include "get_bits.h"
+#include "put_bits.h"
+
+#define CABGT_NEUTRAL_STATE 255 // 50% probability
+
+#define MAX_CODES 17
+#define NUM_GROUPS 8
+#define MAX_VLC_BITS 8
+#define MAX_BUFFER 65536
+
+typedef struct CABGTContext{
+    GetBitContext gb;
+    PutBitContext pb;
+    int buffer_index_old;
+    int buffer_index_new;
+    uint32_t codes_read[NUM_GROUPS];
+    uint8_t transition[256][2];
+    struct {
+        VLC vlc;
+        int size;
+        uint16_t codes[MAX_CODES];
+        uint8_t bits[MAX_CODES];
+        uint8_t lens[MAX_CODES];
+        int8_t *inv_codes;
+        int buffer_index;
+    } groups[NUM_GROUPS];
+    struct {
+        uint16_t code;
+        uint8_t  codename;
+        uint8_t  group;
+    } codes_buffered[MAX_BUFFER];
+}CABGTContext;
+
+void ff_alloc_cabgt_encoder(CABGTContext *c);
+void ff_alloc_cabgt_decoder(CABGTContext *c);
+void ff_dealloc_cabgt_coder(CABGTContext *c);
+void ff_init_cabgt_encoder(CABGTContext *c, uint8_t *buf, int buf_size);
+void ff_init_cabgt_decoder(CABGTContext *c, const uint8_t *buf, int buf_size);
+int ff_cabgt_terminate(CABGTContext *c);
+
+static inline int get_codename(CABGTContext *c, int group, int code){
+    return c->groups[group].inv_codes[code];
+}
+
+// codes_buffered[] contains everything from the earliest code that hasn't yet been completed,
+// up to the latest code that has been allocated an order in the bitstream.
+// it is potentially unbounded, and large buffers are not especially rare;
+// an all-black 1080p frame in ffv1 could cause it to buffer 200000 codes.
+//
+// groups[].buffer_index points to the entry in codes_buffered[] that that group is currently updating.
+// if a group finishes a code, groups[].buffer_index isn't updated until it starts the next code.
+// this matches the decoder behavior of reading a code only when you need to know a bit from it.
+//
+// buffer_index_new is the slot that will be allocated to the next group that needs one.
+//
+// buffer_index_old is the code that is blocking the bitstream writing.
+// when this code completes, we immediately write it and any subsequent complete codes.
+
+static inline void put_cabgt(CABGTContext *c, uint8_t * const state, int bit){
+    int group = *state >> 5;
+    int buffer_index = c->groups[group].buffer_index;
+    int code = c->codes_buffered[buffer_index].code;
+
+    if(!code) {
+        buffer_index = c->buffer_index_new & (MAX_BUFFER-1);
+        c->buffer_index_new = (buffer_index+1) & (MAX_BUFFER-1);
+        c->groups[group].buffer_index = buffer_index;
+        c->codes_buffered[buffer_index].group = group;
+        code = 1;
+        assert(c->buffer_index_new != c->buffer_index_old);
+    }
+    code = (code << 1) + (bit ^ (*state & 1));
+    *state = c->transition[*state][bit];
+    int codename = get_codename(c, group, code);
+    if(codename < 0) {
+        c->codes_buffered[buffer_index].code = code;
+    } else {
+        c->codes_buffered[buffer_index].code = 0;
+        c->codes_buffered[buffer_index].codename = codename;
+        if(buffer_index == c->buffer_index_old) {
+            put_bits(&c->pb, c->groups[group].lens[codename], c->groups[group].bits[codename]);
+            while((buffer_index = (buffer_index+1) & (MAX_BUFFER-1)) != c->buffer_index_new) {
+                if(c->codes_buffered[buffer_index].code)
+                    break;
+                group = c->codes_buffered[buffer_index].group;
+                codename = c->codes_buffered[buffer_index].codename;
+                put_bits(&c->pb, c->groups[group].lens[codename], c->groups[group].bits[codename]);
+            }
+            c->buffer_index_old = buffer_index;
+        }
+    }
+}
+
+static inline int get_cabgt(CABGTContext *c, uint8_t * const restrict state){
+    unsigned group = *state >> 5;
+    unsigned code = c->codes_read[group];
+    if(__builtin_expect(code <= 1, 0))
+        code = (uint16_t)get_vlc2(&c->gb, c->groups[group].vlc.table, MAX_VLC_BITS, 1);
+    unsigned bit = (code ^ *state) & 1;
+    *state = c->transition[*state][bit];
+    c->codes_read[group] = code >> 1;
+    return bit;
+}
+
+#endif /* AVCODEC_CABGT_H */
diff --git a/libavcodec/cabgt_data.h b/libavcodec/cabgt_data.h
new file mode 100644
index 0000000..8f55732
--- /dev/null
+++ b/libavcodec/cabgt_data.h
@@ -0,0 +1,179 @@
+/*
+ * Context Adaptive Binary Group Tester
+ * Copyright (c) 2010 Loren Merritt
+ *
+ * This file is part of FFmpeg.
+ *
+ * FFmpeg is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * FFmpeg is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with FFmpeg; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#include "cabgt.h"
+
+// { huffman length, symbol name }
+// symbols are big-endian, as generated by the cabgt encoder.
+// the decoder wants little-endian.
+// both want lsb-aligned, with a stop-bit in the msb, so only the payload part should be reversed.
+static uint16_t cabgt_tables[NUM_GROUPS][MAX_CODES][2] = {
+// p=0.0326
+// ideal entropy: 0.207268
+// cost: 0.210906
+   {{ 1, 0b1000000000000000 },
+    { 4, 0b11 },
+    { 5, 0b101 },
+    { 5, 0b1001 },
+    { 5, 0b10001 },
+    { 5, 0b100001 },
+    { 5, 0b1000001 },
+    { 5, 0b10000001 },
+    { 5, 0b100000001 },
+    { 5, 0b1000000001 },
+    { 5, 0b10000000001 },
+    { 5, 0b100000000001 },
+    { 5, 0b1000000000001 },
+    { 5, 0b10000000000001 },
+    { 5, 0b100000000000001 },
+    { 5, 0b1000000000000001 }},
+
+// p=0.0943
+// ideal entropy: 0.450662
+// cost: 0.451236
+   {{ 1, 0b10000000 },
+    { 4, 0b10010 },
+    { 4, 0b10001 },
+    { 4, 0b110000 },
+    { 4, 0b101000 },
+    { 4, 0b100001 },
+    { 4, 0b1000001 },
+    { 4, 0b10000001 },
+    { 7, 0b111 },
+    { 7, 0b1101 },
+    { 7, 0b1011 },
+    { 7, 0b11001 },
+    { 7, 0b10101 },
+    { 7, 0b10011 },
+    { 7, 0b110001 },
+    { 7, 0b101001 }},
+
+// p=0.1526
+// ideal entropy: 0.616309
+// cost: 0.617387
+   {{ 1, 0b10000 },
+    { 3, 0b110 },
+    { 3, 0b101 },
+    { 3, 0b1001 },
+    { 4, 0b10001000 },
+    { 6, 0b11100 },
+    { 6, 0b100011 },
+    { 6, 0b1000101 },
+    { 7, 0b10001001 },
+    { 8, 0b1111 },
+    { 8, 0b11101 }},
+
+// p=0.2168
+// ideal entropy: 0.754281
+// cost: 0.755098
+   {{ 1, 0b1000 },
+    { 3, 0b1100 },
+    { 3, 0b1010 },
+    { 3, 0b1001 },
+    { 5, 0b11100 },
+    { 5, 0b11010 },
+    { 5, 0b10110 },
+    { 7, 0b1111 },
+    { 7, 0b11101 },
+    { 7, 0b11011 },
+    { 7, 0b10111 }},
+
+// p=0.2835
+// ideal entropy: 0.860176
+// cost: 0.861949
+   {{ 1, 0b100 },
+    { 4, 0b101000 },
+    { 4, 0b1110 },
+    { 4, 0b1101 },
+    { 4, 0b1011 },
+    { 4, 0b1100000 },
+    { 5, 0b110010 },
+    { 5, 0b110001 },
+    { 5, 0b101010 },
+    { 5, 0b101001 },
+    { 6, 0b1100001 },
+    { 6, 0b11110 },
+    { 7, 0b1100110 },
+    { 7, 0b1010110 },
+    { 7, 0b11111 },
+    { 8, 0b1100111 },
+    { 8, 0b1010111 }},
+
+// p=0.3440
+// ideal entropy: 0.928595
+// cost: 0.930027
+   {{ 2, 0b101 },
+    { 3, 0b100000 },
+    { 3, 0b111 },
+    { 4, 0b1101 },
+    { 4, 0b110000 },
+    { 4, 0b100100 },
+    { 4, 0b100010 },
+    { 4, 0b100001 },
+    { 5, 0b110001 },
+    { 5, 0b100101 },
+    { 5, 0b100011 },
+    { 5, 0b110010 },
+    { 5, 0b100110 },
+    { 6, 0b110011 },
+    { 6, 0b100111 }},
+
+// p=0.4100
+// ideal entropy: 0.976500
+// cost: 0.977799
+   {{ 2, 0b110 },
+    { 2, 0b101 },
+    { 3, 0b1001 },
+    { 3, 0b10000 },
+    { 4, 0b1111 },
+    { 4, 0b11100 },
+    { 5, 0b1000100 },
+    { 6, 0b111011 },
+    { 6, 0b1110100 },
+    { 6, 0b1000111 },
+    { 7, 0b1110101 },
+    { 7, 0b10001011 },
+    { 7, 0b10001101 },
+    { 7, 0b100010100 },
+    { 7, 0b100011000 },
+    { 8, 0b100010101 },
+    { 8, 0b100011001 }},
+
+// p=0.4737
+// ideal entropy: 0.998003
+// cost: 1.000000
+   {{ 4, 0b10000 },
+    { 4, 0b10001 },
+    { 4, 0b10010 },
+    { 4, 0b10011 },
+    { 4, 0b10100 },
+    { 4, 0b10101 },
+    { 4, 0b10110 },
+    { 4, 0b10111 },
+    { 4, 0b11000 },
+    { 4, 0b11001 },
+    { 4, 0b11010 },
+    { 4, 0b11011 },
+    { 4, 0b11100 },
+    { 4, 0b11101 },
+    { 4, 0b11110 },
+    { 4, 0b11111 }},
+};
diff --git a/libavcodec/cabgt_sim.c b/libavcodec/cabgt_sim.c
new file mode 100644
index 0000000..6e4c133
--- /dev/null
+++ b/libavcodec/cabgt_sim.c
@@ -0,0 +1,234 @@
+#define DEBUG
+#include <assert.h>
+#include "avcodec.h"
+#include "cabgt_sim.h"
+
+#define MAX_ELEMS 256
+#define MAX_HUFF_DEPTH 8
+#define MAX_GROUP_DEPTH 15
+
+typedef struct HeapElem {
+    uint64_t val;
+    uint32_t name;
+} HeapElem;
+
+static void heap_sift(HeapElem *h, int root, int size)
+{
+    int child = root*2+1;
+    do {
+        child += h[child].val > h[child+1].val;
+        if(h[root].val <= h[child].val)
+            break;
+        FFSWAP(HeapElem, h[root], h[child]);
+        root = child;
+        child = root*2+1;
+    } while(child < size);
+}
+
+static void build_len_table(uint8_t *dst, uint64_t *stats, int size, int max_depth) {
+    HeapElem h[size+1];
+    int up[2*size];
+    int len[2*size];
+    int offset, i, next;
+
+    assert(size <= 1ULL<<max_depth);
+    h[size].val = UINT64_MAX;
+    for(offset=1; ; offset<<=1){
+        for(i=0; i<size; i++){
+            h[i].name = i;
+            h[i].val = FFMAX(stats[i], offset);
+        }
+        for(i=size/2-1; i>=0; i--)
+            heap_sift(h, i, size);
+
+        for(next=size; next<size*2-1; next++){
+            // merge the two smallest entries, and put it back in the heap
+            uint64_t min1v = h[0].val;
+            up[h[0].name] = next;
+            h[0].val = UINT64_MAX;
+            heap_sift(h, 0, size);
+            up[h[0].name] = next;
+            h[0].name = next;
+            h[0].val += min1v;
+            heap_sift(h, 0, size);
+        }
+
+        len[2*size-2] = 0;
+        for(i=2*size-3; i>=size; i--)
+            len[i] = len[up[i]] + 1;
+        for(i=0; i<size; i++) {
+            dst[i] = len[up[i]] + 1;
+            if(dst[i] > max_depth) break;
+        }
+        if(i==size) break;
+    }
+}
+
+typedef struct {
+    double prob;
+    uint32_t code;
+} TreeElem;
+
+static int treeelem_cmp(TreeElem *a, TreeElem *b) {
+    return a->prob > b->prob ? -1 : a->prob < b->prob;
+}
+
+static double cost_len_table(TreeElem *tree, int size, int max_depth, int print) {
+    uint64_t stats[size];
+    uint8_t lens[size];
+    for(int i=0; i<size; i++)
+        stats[i] = tree[i].prob * UINT_MAX;
+    build_len_table(lens, stats, size, max_depth);
+    double cost = 0;
+    double mean_groupbits = 0;
+    for(int i=0; i<size; i++) {
+        cost += tree[i].prob * lens[i];
+        mean_groupbits += tree[i].prob * av_log2(tree[i].code);
+    }
+    cost /= mean_groupbits;
+    if(print) {
+        TreeElem tree2[size];
+        memcpy(tree2, tree, size*sizeof(*tree));
+        for(int i=0; i<size; i++)
+            tree2[i].code |= lens[i] << 28;
+        qsort(tree2, size, sizeof(*tree), (void*)treeelem_cmp);
+        printf("cost: %.6f\n", cost);
+        for(int i=0; i<size; i++) {
+            int len = tree2[i].code >> 28;
+            int code = tree2[i].code & ((1<<28)-1);
+            printf("%.6f %d ", tree2[i].prob, len);
+            for(int j=av_log2(code)-1; j>=0; j--)
+                printf("%d", (code>>j)&1);
+            printf("\n");
+        }
+        printf("\n");
+    }
+    return cost;
+}
+
+#define dump_tree(tree, size) cost_len_table(tree, size, MAX_HUFF_DEPTH, 1)
+
+static inline int try_tree(TreeElem *tree, int size, TreeElem *btree, int *bsize, double *bcost) {
+    double cost = cost_len_table(tree, size, 31, 0);
+    if(cost < *bcost) // limiting huffman length is slow, so don't do it unless we're going to use the score
+        cost = cost_len_table(tree, size, MAX_HUFF_DEPTH, 0);
+    if(cost < *bcost) {
+        *bcost = cost;
+        *bsize = size;
+        memcpy(btree, tree, size*sizeof(*tree));
+        return 1;
+    }
+    return 0;
+}
+
+#define BRUTEFORCE_MAX 18
+static void bruteforce_tables(double p, TreeElem *tree, int size, int left_pos, int max_size, TreeElem *btree, int *bsize, double *bcost) {
+    for(int i=left_pos; i<size; i++) {
+        if(av_log2(tree[i].code) >= MAX_GROUP_DEPTH)
+            continue;
+        TreeElem backup = tree[i];
+        tree[size].prob = tree[i].prob * p;
+        tree[size].code = (tree[i].code<<1)+1;
+        tree[i].prob *= 1-p;
+        tree[i].code <<= 1;
+        try_tree(tree, size+1, btree, bsize, bcost);
+        if(size+1 < max_size)
+            bruteforce_tables(p, tree, size+1, i, max_size, btree, bsize, bcost);
+        tree[i] = backup;
+    }
+}
+
+static double build_grouptest_vlc_table(double p) {
+    TreeElem tree[MAX_ELEMS];
+    TreeElem btree[MAX_ELEMS];
+    int size = 2;
+    tree[0] = (TreeElem){ 1-p, 2 };
+    tree[1] = (TreeElem){ p, 3 };
+    double bcost = cost_len_table(tree, size, MAX_HUFF_DEPTH, 0);
+    int bsize = size;
+    memcpy(btree, tree, size*sizeof(*tree));
+    bruteforce_tables(p, tree, size, 0, BRUTEFORCE_MAX, btree, &bsize, &bcost);
+    size = bsize;
+    memcpy(tree, btree, bsize*sizeof(*tree));
+    while(size<=MAX_ELEMS) {
+        int improved = 0;
+        for(int i=0; i<size; i++) {
+            if(av_log2(tree[i].code) >= MAX_GROUP_DEPTH)
+                continue;
+            TreeElem backup = tree[i];
+            tree[size].prob = tree[i].prob * p;
+            tree[size].code = (tree[i].code<<1)+1;
+            tree[i].prob *= 1-p;
+            tree[i].code <<= 1;
+            if(try_tree(tree, size+1, btree, &bsize, &bcost))
+                improved = 1;
+            tree[i] = backup;
+        }
+        if(!improved)
+            break;
+        size = bsize;
+        memcpy(tree, btree, bsize*sizeof(*tree));
+    }
+    printf("p=%.4f\n", p);
+    printf("ideal entropy: %.6f\n", p*-log2(p)+(1-p)*-log2(1-p));
+    dump_tree(tree, size);
+    return bcost;
+}
+
+static double ideal_entropy(double p) {
+    return p>0 && p<1 ? p*-log2(p)+(1-p)*-log2(1-p) : 0;
+}
+
+static inline double vlc_entropy(double p) {
+    int i = p*1000;
+    double f = p*1000-i;
+    return (1-f)*gt_entropy[i] + f*gt_entropy[i+1];
+}
+
+// assumes a uniform distribution of inputs.
+// for any other distribution, this would involve an integral and a centroid.
+#define part_cost(left,right) ((right-left)*vlc_entropy((right+left)*.5)*2)
+
+// tweaking partitions gains only a tiny amount of compression from the nonlinearity of the entropy curve.
+// it would be more important if the input distribution were nonuniform.
+static void build_partitions(int npart) {
+    double borders[npart+1];
+    for(int i=0; i<=npart; i++)
+        borders[i] = .5*i/npart;
+    double prev_cost = 0;
+    for(int pass=0; pass<10; pass++) {
+        double total_cost = 0;
+        for(int i=0; i<npart; i++)
+            total_cost += part_cost(borders[i], borders[i+1]);
+        if(total_cost == prev_cost)
+            break;
+        prev_cost = total_cost;
+        for(int i=1; i<npart; i++) {
+            for(double delta=-.0001; delta<.0002; delta+=.0002) {
+                double mid = borders[i];
+                double cost = part_cost(borders[i-1], mid) + part_cost(mid, borders[i+1]);
+                double bcost;
+                do {
+                    bcost = cost;
+                    borders[i] = mid;
+                    mid += delta;
+                    cost = part_cost(borders[i-1], mid) + part_cost(mid, borders[i+1]);
+                } while(cost < bcost);
+            }
+        }
+    }
+    printf("%2d  %.6f  ", npart, prev_cost/.72134752);
+    for(int i=0; i<npart; i++)
+        printf("%.4f ", (borders[i]+borders[i+1])*.5);
+    printf("\n");
+}
+
+int main() {
+//  printf("bins  cost relative to the ideal (non-quantized non-vlc) entropy\n");
+//  for(int i=1; i<=16; i++)
+//      build_partitions(i);
+    double centroids[8] = { 0.0326, 0.0943, 0.1526, 0.2168, 0.2835, 0.3440, 0.4100, 0.4737 };
+    for(int i=0; i<8; i++)
+        build_grouptest_vlc_table(centroids[i]);
+    return 0;
+}
diff --git a/libavcodec/cabgt_sim.h b/libavcodec/cabgt_sim.h
new file mode 100644
index 0000000..071254b
--- /dev/null
+++ b/libavcodec/cabgt_sim.h
@@ -0,0 +1,79 @@
+// bits-per-decision of using grouptesting for probabilities in [0,0.5]
+// tables generated by brute forcing up to size 15, following by hillclimbing
+// subject to max_huff_depth=8, max_group_depth=15
+// (max_huff_depth had negligible effect. max_group_depth and hillclimbing had
+// negligible effect outside the unary coding of very low probabilities.)
+float gt_entropy[501] = {
+0.0666667, 0.0710674, 0.0754698, 0.0798736, 0.0842791, 0.0886860, 0.0930945,
+0.0975046, 0.1019161, 0.1063292, 0.1107438, 0.1151599, 0.1195775, 0.1239966,
+0.1284172, 0.1328393, 0.1372629, 0.1416880, 0.1461145, 0.1505425, 0.1549720,
+0.1594029, 0.1638353, 0.1682692, 0.1727044, 0.1771411, 0.1815793, 0.1860188,
+0.1904597, 0.1949021, 0.1993459, 0.2037910, 0.2082375, 0.2126854, 0.2171347,
+0.2215853, 0.2260373, 0.2304906, 0.2349453, 0.2394013, 0.2438586, 0.2483172,
+0.2527772, 0.2572384, 0.2617009, 0.2661647, 0.2706297, 0.2750577, 0.2793979,
+0.2837383, 0.2880789, 0.2922998, 0.2965110, 0.3007215, 0.3049277, 0.3090065,
+0.3130843, 0.3171610, 0.3212368, 0.3252497, 0.3291920, 0.3331332, 0.3370734,
+0.3410127, 0.3449418, 0.3487475, 0.3525525, 0.3563570, 0.3601609, 0.3639643,
+0.3677670, 0.3707660, 0.3744112, 0.3780563, 0.3817013, 0.3857440, 0.3892482,
+0.3927531, 0.3962589, 0.3997498, 0.4032396, 0.4067298, 0.4102203, 0.4137034,
+0.4171766, 0.4206498, 0.4241227, 0.4275956, 0.4310684, 0.4338846, 0.4371583,
+0.4404322, 0.4437061, 0.4469800, 0.4502540, 0.4535281, 0.4568023, 0.4600765,
+0.4633508, 0.4666251, 0.4702124, 0.4732545, 0.4762966, 0.4793389, 0.4823813,
+0.4854237, 0.4884663, 0.4915090, 0.4945517, 0.4975946, 0.5006376, 0.5036807,
+0.5067238, 0.5097671, 0.5128105, 0.5158540, 0.5188975, 0.5219412, 0.5249710,
+0.5279221, 0.5307008, 0.5334796, 0.5362586, 0.5390379, 0.5418173, 0.5445969,
+0.5473767, 0.5501567, 0.5529369, 0.5556976, 0.5584492, 0.5612008, 0.5639523,
+0.5667036, 0.5694548, 0.5722059, 0.5749568, 0.5777076, 0.5804583, 0.5832089,
+0.5859593, 0.5887096, 0.5909519, 0.5935429, 0.5965094, 0.5989364, 0.6013636,
+0.6037909, 0.6062184, 0.6086460, 0.6110739, 0.6135018, 0.6159299, 0.6183582,
+0.6207867, 0.6232152, 0.6256440, 0.6280728, 0.6304912, 0.6328756, 0.6352597,
+0.6376436, 0.6400272, 0.6424106, 0.6447937, 0.6471766, 0.6495592, 0.6519416,
+0.6543237, 0.6567056, 0.6590872, 0.6614686, 0.6637109, 0.6659211, 0.6681313,
+0.6703416, 0.6725521, 0.6747627, 0.6769734, 0.6791842, 0.6813952, 0.6835991,
+0.6857683, 0.6879372, 0.6901058, 0.6922741, 0.6944421, 0.6966097, 0.6979646,
+0.7001162, 0.7030182, 0.7049992, 0.7069803, 0.7089617, 0.7109433, 0.7129252,
+0.7149072, 0.7168895, 0.7188720, 0.7208547, 0.7228376, 0.7248207, 0.7268041,
+0.7287336, 0.7306453, 0.7325568, 0.7344680, 0.7363791, 0.7382900, 0.7402008,
+0.7421113, 0.7440217, 0.7459318, 0.7478418, 0.7497517, 0.7516613, 0.7535708,
+0.7554801, 0.7573893, 0.7592983, 0.7612071, 0.7631158, 0.7650243, 0.7669327,
+0.7688409, 0.7707489, 0.7726466, 0.7745320, 0.7762206, 0.7779848, 0.7797489,
+0.7815484, 0.7832389, 0.7849297, 0.7866207, 0.7883119, 0.7899844, 0.7916416,
+0.7932987, 0.7949558, 0.7966128, 0.7982631, 0.7998899, 0.8015165, 0.8031428,
+0.8047689, 0.8063948, 0.8080204, 0.8096458, 0.8112709, 0.8128958, 0.8145205,
+0.8161449, 0.8177691, 0.8193931, 0.8210168, 0.8226402, 0.8242634, 0.8258864,
+0.8275091, 0.8291058, 0.8306360, 0.8321661, 0.8336961, 0.8352260, 0.8367558,
+0.8382856, 0.8398152, 0.8413448, 0.8428743, 0.8444037, 0.8459330, 0.8467568,
+0.8488186, 0.8501002, 0.8513741, 0.8526478, 0.8539215, 0.8551950, 0.8564685,
+0.8577418, 0.8590150, 0.8602881, 0.8615612, 0.8628341, 0.8641069, 0.8653796,
+0.8666522, 0.8679247, 0.8691970, 0.8704693, 0.8716697, 0.8728531, 0.8740362,
+0.8752190, 0.8764016, 0.8775840, 0.8787662, 0.8799481, 0.8811297, 0.8823112,
+0.8834924, 0.8846733, 0.8858541, 0.8870346, 0.8882149, 0.8893949, 0.8905748,
+0.8917544, 0.8929338, 0.8941130, 0.8952919, 0.8964707, 0.8976492, 0.8988275,
+0.9000056, 0.9011835, 0.9023612, 0.9035387, 0.9047160, 0.9058931, 0.9070700,
+0.9082466, 0.9094231, 0.9105994, 0.9117755, 0.9128839, 0.9138371, 0.9147901,
+0.9157431, 0.9166961, 0.9176489, 0.9186016, 0.9195543, 0.9205068, 0.9214593,
+0.9224117, 0.9233639, 0.9243161, 0.9252682, 0.9262202, 0.9271721, 0.9281240,
+0.9290757, 0.9300273, 0.9309788, 0.9319303, 0.9328816, 0.9338328, 0.9347840,
+0.9357350, 0.9366860, 0.9375110, 0.9383314, 0.9391518, 0.9399724, 0.9407931,
+0.9416139, 0.9424349, 0.9432559, 0.9440771, 0.9448984, 0.9457199, 0.9465414,
+0.9473631, 0.9481849, 0.9490068, 0.9498288, 0.9506509, 0.9514732, 0.9522956,
+0.9531181, 0.9539407, 0.9547634, 0.9555862, 0.9564091, 0.9572322, 0.9580553,
+0.9588786, 0.9597020, 0.9605254, 0.9613490, 0.9621638, 0.9627260, 0.9632881,
+0.9638504, 0.9644128, 0.9649752, 0.9655377, 0.9661003, 0.9666630, 0.9672257,
+0.9677886, 0.9683515, 0.9689145, 0.9694776, 0.9700407, 0.9706040, 0.9711673,
+0.9717307, 0.9722942, 0.9728578, 0.9734084, 0.9739579, 0.9745074, 0.9750569,
+0.9756065, 0.9761561, 0.9767057, 0.9772554, 0.9778051, 0.9783549, 0.9789047,
+0.9794545, 0.9800043, 0.9805542, 0.9811042, 0.9816542, 0.9822042, 0.9827543,
+0.9833044, 0.9838292, 0.9843537, 0.9848780, 0.9853694, 0.9858184, 0.9862673,
+0.9867163, 0.9871653, 0.9876143, 0.9880634, 0.9885124, 0.9889615, 0.9894105,
+0.9898596, 0.9903088, 0.9907579, 0.9912071, 0.9916381, 0.9920218, 0.9924055,
+0.9927891, 0.9931727, 0.9935562, 0.9939397, 0.9943101, 0.9946747, 0.9950392,
+0.9954037, 0.9957681, 0.9961112, 0.9963784, 0.9965952, 0.9968029, 0.9970104,
+0.9972179, 0.9974252, 0.9976325, 0.9978396, 0.9980467, 0.9982537, 0.9984607,
+0.9986273, 0.9987666, 0.9989059, 0.9990452, 0.9991843, 0.9993235, 0.9994625,
+0.9995558, 0.9996123, 0.9996688, 0.9997253, 0.9997817, 0.9998380, 0.9998944,
+0.9999507, 1.0000000, 1.0000000, 1.0000000, 1.0000000, 1.0000000, 1.0000000,
+1.0000000, 1.0000000, 1.0000000, 1.0000000, 1.0000000, 1.0000000, 1.0000000,
+1.0000000, 1.0000000, 1.0000000, 1.0000000, 1.0000000, 1.0000000, 1.0000000,
+1.0000000, 1.0000000, 1.0000000, 1.0000000,
+};
diff --git a/libavcodec/cabgt_sim.pl b/libavcodec/cabgt_sim.pl
new file mode 100755
index 0000000..aca5b38
--- /dev/null
+++ b/libavcodec/cabgt_sim.pl
@@ -0,0 +1,213 @@
+#!/usr/bin/perl -w
+# simulations of using vlc with group testing to replace cabrc.
+use Inline C;
+
+sub log2 {
+    return log(shift) / log(2);
+}
+
+$nprobs = 16;
+$huffsize = 8;
+$groupsize = 15;
+#print "using $nprobs probability levels, and $groupsize decisions per group.\n";
+
+$sum = 0;
+for(1..$nprobs-1) {
+    my $p = $_/$nprobs;
+    if($p < .5) { $p = 1-$p; }
+    $sum += ($groupsize-1)/2 * -log2($p);
+}
+#print "bits per frame to flush group testers: $sum\n\n";
+
+$dp = .1;
+$sum = 0;
+$quantsum = 0;
+#$vlcsum = 0;
+for($p=$dp/2; $p<1; $p+=$dp) {
+    $quantp = int($p*$nprobs+.5)/$nprobs;
+    if($quantp == 0) { $quantp = 1/$nprobs; }
+    if($quantp == 1) { $quantp = 1-1/$nprobs; }
+    $sum += $dp * ($p * -log2($p) + (1-$p) * -log2(1-$p));
+    $quantsum += $dp * ($p * -log2($quantp) + (1-$p) * -log2(1-$quantp));
+#   $vlcsum += $dp * grouptest_vlc_table_cost($p, $quantp);
+#   printf STDERR "%.3f\r", $p;
+}
+#printf "assuming evenly distributed input probabilites.\n";
+#printf "ideal compression ratio: %.10f\n", $sum;
+#printf "quantized compression ratio: %.10f\n", $quantsum;
+#printf "vlc compression ratio: %.10f\n", $vlcsum;
+#printf "overhead: %.5f%%\n", ($vlcsum/$sum-1)*100;
+
+# btw, the uniform assumption is pretty good for ffv1. actually, it's 6% on the min prob (8/256), 6% on the max (248/256), and uniform in between. which may reflect actual stats, or may be an artifact of the DFA method of adaption.
+
+$x = .3;
+build_grouptest_vlc_table($x);
+printf "ideal entropy: %.5f\n", $x*-log2($x) + (1-$x)*-log2(1-$x);
+
+sub init_group_bits_tab {
+    # precompute the mapping from group codeword to number of ones and zeros, to be used in computation of codeword probabilities
+    # codeword is stored as 1-15 payload bits, plus a stop bit in the msb.
+    $initted_group_bits_tab and return;
+    $initted_group_bits_tab = 1;
+    foreach $code (2 .. (2<<$groupsize)-1) {
+        my $bits = $code;
+        $group_bits_tab{$code}[0] = $group_bits_tab{$code}[1] = 0;
+        while($bits > 1) {
+            $group_bits_tab{$code}[$bits&1]++;
+            $bits >>= 1;
+        }
+        $group_bits_tab{$code}[2] = $group_bits_tab{$code}[0] + $group_bits_tab{$code}[1];
+    }
+}
+
+sub dump_codes {
+    my @codes = @_;
+#   @codes = sort {$b->[0] <=> $a->[0]} @codes;
+    my $cost = cost_len_table($huffsize, @codes);
+    printf "cost %.5f\n", $cost;
+    my $toggle;
+    my @lens = build_len_table($huffsize, grep {$toggle ^= 1} @codes);
+    for(0..$#codes/2) {
+        my $code = $codes[$_*2+1];
+        my $bits = $group_bits_tab{$code}[2];
+        $code &= (1<<$bits)-1;
+        printf "%0*b %d %.5f\n", $bits, $code, $lens[$_], $codes[$_*2+0];
+    }
+    print "\n";
+}
+
+sub build_grouptest_vlc_table {
+    my ($p) = @_;
+    init_group_bits_tab();
+    my @codes = (($p,0b11), (1-$p,0b10));
+    my $bcost = cost_len_table($huffsize, @codes);
+    while(1) {
+        my $improved;
+        print "new iteration\n";
+        dump_codes(@codes);
+        foreach $i (0..$#codes/2) {
+            my @codes2 = @codes;
+            my ($leafp, $leafcode) = splice @codes2, $i*2, 2;
+            next if $leafcode >= 1<<$groupsize;
+            push @codes2, ($leafp*$p, ($leafcode<<1)+1);
+            push @codes2, ($leafp*(1-$p), $leafcode<<1);
+            my $cost = cost_len_table($huffsize, @codes2);
+            dump_codes(@codes2);
+            if($cost < $bcost) {
+                $improved = 1;
+                $bcost = $cost;
+                @bcodes = @codes2;
+            }
+        }
+        last if !$improved;
+        @codes = @bcodes;
+        last if @codes == (1<<$huffsize);
+    }
+    print "final\n";
+    dump_codes(@codes);
+}
+
+__END__
+__C__
+
+#include <assert.h>
+
+#define FFSWAP(type,a,b) do{type SWAP_tmp= b; b= a; a= SWAP_tmp;}while(0)
+#define FFMAX(a,b) ((a) > (b) ? (a) : (b))
+
+typedef struct HeapElem {
+    uint64_t val;
+    uint32_t name;
+} HeapElem;
+
+static void heap_sift(HeapElem *h, int root, int size)
+{
+    int child = root*2+1;
+    do {
+        child += h[child].val > h[child+1].val;
+        if(h[root].val <= h[child].val)
+            break;
+        FFSWAP(HeapElem, h[root], h[child]);
+        root = child;
+        child = root*2+1;
+    } while(child < size);
+}
+
+void build_len_table_internal(uint8_t *dst, uint64_t *stats, int size, int max_depth) {
+    HeapElem h[size+1];
+    int up[2*size];
+    int len[2*size];
+    int offset, i, next;
+
+    assert(size <= 1ULL<<max_depth);
+    h[size].val = UINT64_MAX;
+    for(offset=1; ; offset<<=1){
+        for(i=0; i<size; i++){
+            h[i].name = i;
+            h[i].val = FFMAX(stats[i], offset);
+        }
+        for(i=size/2-1; i>=0; i--)
+            heap_sift(h, i, size);
+
+        for(next=size; next<size*2-1; next++){
+            // merge the two smallest entries, and put it back in the heap
+            uint64_t min1v = h[0].val;
+            up[h[0].name] = next;
+            h[0].val = UINT64_MAX;
+            heap_sift(h, 0, size);
+            up[h[0].name] = next;
+            h[0].name = next;
+            h[0].val += min1v;
+            heap_sift(h, 0, size);
+        }
+
+        len[2*size-2] = 0;
+        for(i=2*size-3; i>=size; i--)
+            len[i] = len[up[i]] + 1;
+        for(i=0; i<size; i++) {
+            dst[i] = len[up[i]] + 1;
+            if(dst[i] > max_depth) break;
+        }
+        if(i==size) break;
+    }
+}
+
+void build_len_table(int max_depth, ...) {
+    Inline_Stack_Vars;
+    int n = Inline_Stack_Items-1;
+    int i;
+    uint64_t stats[n];
+    uint8_t lens[n];
+    for(i=0; i<n; i++)
+        stats[i] = SvNV(Inline_Stack_Item(i+1)) * UINT_MAX;
+    build_len_table_internal(lens, stats, n, max_depth);
+    Inline_Stack_Reset;
+    for(i=0; i<n; i++)
+        Inline_Stack_Push(sv_2mortal(newSViv(lens[i])));
+    Inline_Stack_Done;
+}
+
+float cost_len_table(int max_depth, ...) {
+    Inline_Stack_Vars;
+    int n = Inline_Stack_Items-1;
+    assert(!(n&1));
+    n >>= 1;
+    int i;
+    float statsf[n];
+    uint64_t stats[n];
+    uint32_t codes[n];
+    uint8_t lens[n];
+    for(i=0; i<n; i++) {
+        statsf[i] = SvNV(Inline_Stack_Item(i*2+1));
+        stats[i] = statsf[i] * UINT_MAX;
+        codes[i] = SvIV(Inline_Stack_Item(i*2+2));
+    }
+    build_len_table_internal(lens, stats, n, max_depth);
+    float cost = 0;
+    float mean_groupbits = 0;
+    for(i=0; i<n; i++) {
+        cost += statsf[i] * lens[i];
+        mean_groupbits += statsf[i] * (31 - __builtin_clz(codes[i]));
+    }
+    return cost / mean_groupbits;
+}
diff --git a/libavcodec/ffv1.c b/libavcodec/ffv1.c
index e3b71f7..785e946 100644
--- a/libavcodec/ffv1.c
+++ b/libavcodec/ffv1.c
@@ -29,10 +29,18 @@
 #include "get_bits.h"
 #include "put_bits.h"
 #include "dsputil.h"
-#include "rangecoder.h"
 #include "golomb.h"
 #include "mathops.h"
 
+#include "cabgt.h"
+#define RangeCoder CABGTContext
+#define put_rac put_cabgt
+#define get_rac get_cabgt
+#define ff_rac_terminate ff_cabgt_terminate
+#define ff_init_range_encoder ff_init_cabgt_encoder
+#define ff_init_range_decoder ff_init_cabgt_decoder
+#define ff_build_rac_states(...)
+
 #define MAX_PLANES 4
 #define CONTEXT_SIZE 32
 
@@ -417,7 +425,7 @@ static inline int encode_line(FFV1Context *s, int w, int_fast16_t *sample[2], in
     int run_mode=0;
 
     if(s->ac){
-        if(c->bytestream_end - c->bytestream < w*20){
+        if(c->pb.buf_end - c->pb.buf_ptr < w*20){ // not a very good estimate
             av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
             return -1;
         }
@@ -559,7 +567,7 @@ static void write_quant_table(RangeCoder *c, int16_t *quant_table){
     int last=0;
     int i;
     uint8_t state[CONTEXT_SIZE];
-    memset(state, 128, sizeof(state));
+    memset(state, CABGT_NEUTRAL_STATE, sizeof(state));
 
     for(i=1; i<128 ; i++){
         if(quant_table[i] != quant_table[i-1]){
@@ -575,7 +583,7 @@ static void write_header(FFV1Context *f){
     int i;
     RangeCoder * const c= &f->c;
 
-    memset(state, 128, sizeof(state));
+    memset(state, CABGT_NEUTRAL_STATE, sizeof(state));
 
     put_symbol(c, state, f->version, 0);
     put_symbol(c, state, f->avctx->coder_type, 0);
@@ -619,6 +627,9 @@ static av_cold int encode_init(AVCodecContext *avctx)
     s->version=0;
     s->ac= avctx->coder_type;
 
+    if(s->ac)
+        ff_alloc_cabgt_encoder(&s->c);
+
     s->plane_count=2;
     for(i=0; i<256; i++){
         if(avctx->bits_per_raw_sample <=8){
@@ -707,12 +718,12 @@ static void clear_state(FFV1Context *f){
     for(i=0; i<f->plane_count; i++){
         PlaneContext *p= &f->plane[i];
 
-        p->interlace_bit_state[0]= 128;
-        p->interlace_bit_state[1]= 128;
+        p->interlace_bit_state[0]= CABGT_NEUTRAL_STATE;
+        p->interlace_bit_state[1]= CABGT_NEUTRAL_STATE;
 
         for(j=0; j<p->context_count; j++){
             if(f->ac){
-                memset(p->state[j], 128, sizeof(uint8_t)*CONTEXT_SIZE);
+                memset(p->state[j], CABGT_NEUTRAL_STATE, sizeof(uint8_t)*CONTEXT_SIZE);
             }else{
                 p->vlc_state[j].drift= 0;
                 p->vlc_state[j].error_sum= 4; //FFMAX((RANGE + 32)/64, 2);
@@ -732,7 +743,7 @@ static int encode_frame(AVCodecContext *avctx, unsigned char *buf, int buf_size,
     const int height= f->height;
     AVFrame * const p= &f->picture;
     int used_count= 0;
-    uint8_t keystate=128;
+    uint8_t keystate= CABGT_NEUTRAL_STATE;
 
     ff_init_range_encoder(c, buf, buf_size);
     ff_build_rac_states(c, 0.05*(1LL<<32), 256-8);
@@ -791,6 +802,8 @@ static av_cold int common_end(AVCodecContext *avctx){
         av_freep(&p->vlc_state);
     }
 
+    ff_dealloc_cabgt_coder(&s->c);
+
     return 0;
 }
 
@@ -935,7 +948,7 @@ static int read_quant_table(RangeCoder *c, int16_t *quant_table, int scale){
     int i=0;
     uint8_t state[CONTEXT_SIZE];
 
-    memset(state, 128, sizeof(state));
+    memset(state, CABGT_NEUTRAL_STATE, sizeof(state));
 
     for(v=0; i<128 ; v++){
         int len= get_symbol(c, state, 0) + 1;
@@ -963,7 +976,7 @@ static int read_header(FFV1Context *f){
     int i, context_count;
     RangeCoder * const c= &f->c;
 
-    memset(state, 128, sizeof(state));
+    memset(state, CABGT_NEUTRAL_STATE, sizeof(state));
 
     f->version= get_symbol(c, state, 0);
     f->ac= f->avctx->coder_type= get_symbol(c, state, 0);
@@ -1038,10 +1051,12 @@ static int read_header(FFV1Context *f){
 
 static av_cold int decode_init(AVCodecContext *avctx)
 {
-//    FFV1Context *s = avctx->priv_data;
+    FFV1Context *s = avctx->priv_data;
 
     common_init(avctx);
 
+    ff_alloc_cabgt_decoder(&s->c);
+
     return 0;
 }
 
@@ -1054,7 +1069,7 @@ static int decode_frame(AVCodecContext *avctx, void *data, int *data_size, AVPac
     const int height= f->height;
     AVFrame * const p= &f->picture;
     int bytes_read;
-    uint8_t keystate= 128;
+    uint8_t keystate= CABGT_NEUTRAL_STATE;
 
     AVFrame *picture = data;
 
@@ -1084,7 +1099,7 @@ static int decode_frame(AVCodecContext *avctx, void *data, int *data_size, AVPac
         av_log(avctx, AV_LOG_ERROR, "keyframe:%d coder:%d\n", p->key_frame, f->ac);
 
     if(!f->ac){
-        bytes_read = c->bytestream - c->bytestream_start - 1;
+        bytes_read = get_bits_count(&c->gb)/8;
         if(bytes_read ==0) av_log(avctx, AV_LOG_ERROR, "error at end of AC stream\n"); //FIXME
 //printf("pos=%d\n", bytes_read);
         init_get_bits(&f->gb, buf + bytes_read, buf_size - bytes_read);
@@ -1114,7 +1129,7 @@ static int decode_frame(AVCodecContext *avctx, void *data, int *data_size, AVPac
     *data_size = sizeof(AVFrame);
 
     if(f->ac){
-        bytes_read= c->bytestream - c->bytestream_start - 1;
+        bytes_read = get_bits_count(&c->gb)/8;
         if(bytes_read ==0) av_log(f->avctx, AV_LOG_ERROR, "error at end of frame\n");
     }else{
         bytes_read+= (get_bits_count(&f->gb)+7)/8;
diff --git a/libavcodec/rangecoder.c b/libavcodec/rangecoder.c
index d750e65..b0b8676 100644
--- a/libavcodec/rangecoder.c
+++ b/libavcodec/rangecoder.c
@@ -130,12 +130,12 @@ int main(void){
     memset(state, 128, sizeof(state));
 
     for(i=0; i<SIZE; i++){
-        r[i] = av_lfg_get(&prng) % 7;
+        r[i] = (av_lfg_get(&prng) % 7) & 1;
     }
 
     for(i=0; i<SIZE; i++){
 START_TIMER
-        put_rac(&c, state, r[i]&1);
+        put_rac(&c, state, r[i]);
 STOP_TIMER("put_rac")
     }
 
@@ -147,8 +147,8 @@ STOP_TIMER("put_rac")
 
     for(i=0; i<SIZE; i++){
 START_TIMER
-        if( (r[i]&1) != get_rac(&c, state) )
-            av_log(NULL, AV_LOG_DEBUG, "rac failure at %d\n", i);
+        if( r[i] != get_rac(&c, state) )
+            av_log(NULL, AV_LOG_ERROR, "rac failure at %d\n", i);
 STOP_TIMER("get_rac")
     }
 
diff --git a/libavutil/bswap.h b/libavutil/bswap.h
index 74c7af3..c4eab3b 100644
--- a/libavutil/bswap.h
+++ b/libavutil/bswap.h
@@ -29,6 +29,7 @@
 #include <stdint.h>
 #include "config.h"
 #include "attributes.h"
+#include "common.h"
 
 #if   ARCH_ARM
 #   include "arm/bswap.h"
@@ -98,4 +99,11 @@ static inline uint64_t av_const bswap_64(uint64_t x)
 #define le2me_64(x) (x)
 #endif
 
+static av_always_inline uint32_t bitswap_32(uint32_t x) {
+    return av_reverse[x&0xFF]<<24
+         | av_reverse[(x>>8)&0xFF]<<16
+         | av_reverse[(x>>16)&0xFF]<<8
+         | av_reverse[x>>24];
+}
+
 #endif /* AVUTIL_BSWAP_H */