git.sesse.net Git - ffmpeg/blob - libavcodec/cabac.h

   1 /*
   2  * H.26L/H.264/AVC/JVT/14496-10/... encoder/decoder
   3  * Copyright (c) 2003 Michael Niedermayer <michaelni@gmx.at>
   4  *
   5  * This file is part of FFmpeg.
   6  *
   7  * FFmpeg is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * FFmpeg is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with FFmpeg; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  20  *
  21  */
  22
  23 /**
  24  * @file cabac.h
  25  * Context Adaptive Binary Arithmetic Coder.
  26  */
  27
  28 #ifndef CABAC_H
  29 #define CABAC_H
  30
  31 #include "bitstream.h"
  32
  33 //#undef NDEBUG
  34 #include <assert.h>
  35 #ifdef ARCH_X86
  36 #include "x86_cpu.h"
  37 #endif
  38
  39 #define CABAC_BITS 16
  40 #define CABAC_MASK ((1<<CABAC_BITS)-1)
  41 #define BRANCHLESS_CABAC_DECODER 1
  42 //#define ARCH_X86_DISABLED 1
  43
  44 typedef struct CABACContext{
  45     int low;
  46     int range;
  47     int outstanding_count;
  48 #ifdef STRICT_LIMITS
  49     int symCount;
  50 #endif
  51     const uint8_t *bytestream_start;
  52     const uint8_t *bytestream;
  53     const uint8_t *bytestream_end;
  54     PutBitContext pb;
  55 }CABACContext;
  56
  57 extern uint8_t ff_h264_mlps_state[4*64];
  58 extern uint8_t ff_h264_lps_range[4*2*64];  ///< rangeTabLPS
  59 extern uint8_t ff_h264_mps_state[2*64];     ///< transIdxMPS
  60 extern uint8_t ff_h264_lps_state[2*64];     ///< transIdxLPS
  61 extern const uint8_t ff_h264_norm_shift[512];
  62
  63
  64 void ff_init_cabac_encoder(CABACContext *c, uint8_t *buf, int buf_size);
  65 void ff_init_cabac_decoder(CABACContext *c, const uint8_t *buf, int buf_size);
  66 void ff_init_cabac_states(CABACContext *c);
  67
  68
  69 static inline void put_cabac_bit(CABACContext *c, int b){
  70     put_bits(&c->pb, 1, b);
  71     for(;c->outstanding_count; c->outstanding_count--){
  72         put_bits(&c->pb, 1, 1-b);
  73     }
  74 }
  75
  76 static inline void renorm_cabac_encoder(CABACContext *c){
  77     while(c->range < 0x100){
  78         //FIXME optimize
  79         if(c->low<0x100){
  80             put_cabac_bit(c, 0);
  81         }else if(c->low<0x200){
  82             c->outstanding_count++;
  83             c->low -= 0x100;
  84         }else{
  85             put_cabac_bit(c, 1);
  86             c->low -= 0x200;
  87         }
  88
  89         c->range+= c->range;
  90         c->low += c->low;
  91     }
  92 }
  93
  94 static void put_cabac(CABACContext *c, uint8_t * const state, int bit){
  95     int RangeLPS= ff_h264_lps_range[2*(c->range&0xC0) + *state];
  96
  97     if(bit == ((*state)&1)){
  98         c->range -= RangeLPS;
  99         *state= ff_h264_mps_state[*state];
 100     }else{
 101         c->low += c->range - RangeLPS;
 102         c->range = RangeLPS;
 103         *state= ff_h264_lps_state[*state];
 104     }
 105
 106     renorm_cabac_encoder(c);
 107
 108 #ifdef STRICT_LIMITS
 109     c->symCount++;
 110 #endif
 111 }
 112
 113 static void put_cabac_static(CABACContext *c, int RangeLPS, int bit){
 114     assert(c->range > RangeLPS);
 115
 116     if(!bit){
 117         c->range -= RangeLPS;
 118     }else{
 119         c->low += c->range - RangeLPS;
 120         c->range = RangeLPS;
 121     }
 122
 123     renorm_cabac_encoder(c);
 124
 125 #ifdef STRICT_LIMITS
 126     c->symCount++;
 127 #endif
 128 }
 129
 130 /**
 131  * @param bit 0 -> write zero bit, !=0 write one bit
 132  */
 133 static void put_cabac_bypass(CABACContext *c, int bit){
 134     c->low += c->low;
 135
 136     if(bit){
 137         c->low += c->range;
 138     }
 139 //FIXME optimize
 140     if(c->low<0x200){
 141         put_cabac_bit(c, 0);
 142     }else if(c->low<0x400){
 143         c->outstanding_count++;
 144         c->low -= 0x200;
 145     }else{
 146         put_cabac_bit(c, 1);
 147         c->low -= 0x400;
 148     }
 149
 150 #ifdef STRICT_LIMITS
 151     c->symCount++;
 152 #endif
 153 }
 154
 155 /**
 156  *
 157  * @return the number of bytes written
 158  */
 159 static int put_cabac_terminate(CABACContext *c, int bit){
 160     c->range -= 2;
 161
 162     if(!bit){
 163         renorm_cabac_encoder(c);
 164     }else{
 165         c->low += c->range;
 166         c->range= 2;
 167
 168         renorm_cabac_encoder(c);
 169
 170         assert(c->low <= 0x1FF);
 171         put_cabac_bit(c, c->low>>9);
 172         put_bits(&c->pb, 2, ((c->low>>7)&3)|1);
 173
 174         flush_put_bits(&c->pb); //FIXME FIXME FIXME XXX wrong
 175     }
 176
 177 #ifdef STRICT_LIMITS
 178     c->symCount++;
 179 #endif
 180
 181     return (put_bits_count(&c->pb)+7)>>3;
 182 }
 183
 184 /**
 185  * put (truncated) unary binarization.
 186  */
 187 static void put_cabac_u(CABACContext *c, uint8_t * state, int v, int max, int max_index, int truncated){
 188     int i;
 189
 190     assert(v <= max);
 191
 192 #if 1
 193     for(i=0; i<v; i++){
 194         put_cabac(c, state, 1);
 195         if(i < max_index) state++;
 196     }
 197     if(truncated==0 || v<max)
 198         put_cabac(c, state, 0);
 199 #else
 200     if(v <= max_index){
 201         for(i=0; i<v; i++){
 202             put_cabac(c, state+i, 1);
 203         }
 204         if(truncated==0 || v<max)
 205             put_cabac(c, state+i, 0);
 206     }else{
 207         for(i=0; i<=max_index; i++){
 208             put_cabac(c, state+i, 1);
 209         }
 210         for(; i<v; i++){
 211             put_cabac(c, state+max_index, 1);
 212         }
 213         if(truncated==0 || v<max)
 214             put_cabac(c, state+max_index, 0);
 215     }
 216 #endif
 217 }
 218
 219 /**
 220  * put unary exp golomb k-th order binarization.
 221  */
 222 static void put_cabac_ueg(CABACContext *c, uint8_t * state, int v, int max, int is_signed, int k, int max_index){
 223     int i;
 224
 225     if(v==0)
 226         put_cabac(c, state, 0);
 227     else{
 228         const int sign= v < 0;
 229
 230         if(is_signed) v= FFABS(v);
 231
 232         if(v<max){
 233             for(i=0; i<v; i++){
 234                 put_cabac(c, state, 1);
 235                 if(i < max_index) state++;
 236             }
 237
 238             put_cabac(c, state, 0);
 239         }else{
 240             int m= 1<<k;
 241
 242             for(i=0; i<max; i++){
 243                 put_cabac(c, state, 1);
 244                 if(i < max_index) state++;
 245             }
 246
 247             v -= max;
 248             while(v >= m){ //FIXME optimize
 249                 put_cabac_bypass(c, 1);
 250                 v-= m;
 251                 m+= m;
 252             }
 253             put_cabac_bypass(c, 0);
 254             while(m>>=1){
 255                 put_cabac_bypass(c, v&m);
 256             }
 257         }
 258
 259         if(is_signed)
 260             put_cabac_bypass(c, sign);
 261     }
 262 }
 263
 264 static void refill(CABACContext *c){
 265 #if CABAC_BITS == 16
 266         c->low+= (c->bytestream[0]<<9) + (c->bytestream[1]<<1);
 267 #else
 268         c->low+= c->bytestream[0]<<1;
 269 #endif
 270     c->low -= CABAC_MASK;
 271     c->bytestream+= CABAC_BITS/8;
 272 }
 273
 274 static void refill2(CABACContext *c){
 275     int i, x;
 276
 277     x= c->low ^ (c->low-1);
 278     i= 7 - ff_h264_norm_shift[x>>(CABAC_BITS-1)];
 279
 280     x= -CABAC_MASK;
 281
 282 #if CABAC_BITS == 16
 283         x+= (c->bytestream[0]<<9) + (c->bytestream[1]<<1);
 284 #else
 285         x+= c->bytestream[0]<<1;
 286 #endif
 287
 288     c->low += x<<i;
 289     c->bytestream+= CABAC_BITS/8;
 290 }
 291
 292 static inline void renorm_cabac_decoder(CABACContext *c){
 293     while(c->range < 0x100){
 294         c->range+= c->range;
 295         c->low+= c->low;
 296         if(!(c->low & CABAC_MASK))
 297             refill(c);
 298     }
 299 }
 300
 301 static inline void renorm_cabac_decoder_once(CABACContext *c){
 302 #ifdef ARCH_X86_DISABLED
 303     int temp;
 304 #if 0
 305     //P3:683    athlon:475
 306     asm(
 307         "lea -0x100(%0), %2         \n\t"
 308         "shr $31, %2                \n\t"  //FIXME 31->63 for x86-64
 309         "shl %%cl, %0               \n\t"
 310         "shl %%cl, %1               \n\t"
 311         : "+r"(c->range), "+r"(c->low), "+c"(temp)
 312     );
 313 #elif 0
 314     //P3:680    athlon:474
 315     asm(
 316         "cmp $0x100, %0             \n\t"
 317         "setb %%cl                  \n\t"  //FIXME 31->63 for x86-64
 318         "shl %%cl, %0               \n\t"
 319         "shl %%cl, %1               \n\t"
 320         : "+r"(c->range), "+r"(c->low), "+c"(temp)
 321     );
 322 #elif 1
 323     int temp2;
 324     //P3:665    athlon:517
 325     asm(
 326         "lea -0x100(%0), %%eax      \n\t"
 327         "cdq                        \n\t"
 328         "mov %0, %%eax              \n\t"
 329         "and %%edx, %0              \n\t"
 330         "and %1, %%edx              \n\t"
 331         "add %%eax, %0              \n\t"
 332         "add %%edx, %1              \n\t"
 333         : "+r"(c->range), "+r"(c->low), "+a"(temp), "+d"(temp2)
 334     );
 335 #elif 0
 336     int temp2;
 337     //P3:673    athlon:509
 338     asm(
 339         "cmp $0x100, %0             \n\t"
 340         "sbb %%edx, %%edx           \n\t"
 341         "mov %0, %%eax              \n\t"
 342         "and %%edx, %0              \n\t"
 343         "and %1, %%edx              \n\t"
 344         "add %%eax, %0              \n\t"
 345         "add %%edx, %1              \n\t"
 346         : "+r"(c->range), "+r"(c->low), "+a"(temp), "+d"(temp2)
 347     );
 348 #else
 349     int temp2;
 350     //P3:677    athlon:511
 351     asm(
 352         "cmp $0x100, %0             \n\t"
 353         "lea (%0, %0), %%eax        \n\t"
 354         "lea (%1, %1), %%edx        \n\t"
 355         "cmovb %%eax, %0            \n\t"
 356         "cmovb %%edx, %1            \n\t"
 357         : "+r"(c->range), "+r"(c->low), "+a"(temp), "+d"(temp2)
 358     );
 359 #endif
 360 #else
 361     //P3:675    athlon:476
 362     int shift= (uint32_t)(c->range - 0x100)>>31;
 363     c->range<<= shift;
 364     c->low  <<= shift;
 365 #endif
 366     if(!(c->low & CABAC_MASK))
 367         refill(c);
 368 }
 369
 370 static av_always_inline int get_cabac_inline(CABACContext *c, uint8_t * const state){
 371     //FIXME gcc generates duplicate load/stores for c->low and c->range
 372 #define LOW          "0"
 373 #define RANGE        "4"
 374 #ifdef ARCH_X86_64
 375 #define BYTESTART   "16"
 376 #define BYTE        "24"
 377 #define BYTEEND     "32"
 378 #else
 379 #define BYTESTART   "12"
 380 #define BYTE        "16"
 381 #define BYTEEND     "20"
 382 #endif
 383 #if defined(ARCH_X86) && defined(CONFIG_7REGS) && defined(HAVE_EBX_AVAILABLE) && !defined(BROKEN_RELOCATIONS)
 384     int bit;
 385
 386 #ifndef BRANCHLESS_CABAC_DECODER
 387     asm volatile(
 388         "movzbl (%1), %0                        \n\t"
 389         "movl "RANGE    "(%2), %%ebx            \n\t"
 390         "movl "RANGE    "(%2), %%edx            \n\t"
 391         "andl $0xC0, %%ebx                      \n\t"
 392         "movzbl "MANGLE(ff_h264_lps_range)"(%0, %%ebx, 2), %%esi\n\t"
 393         "movl "LOW      "(%2), %%ebx            \n\t"
 394 //eax:state ebx:low, edx:range, esi:RangeLPS
 395         "subl %%esi, %%edx                      \n\t"
 396         "movl %%edx, %%ecx                      \n\t"
 397         "shll $17, %%ecx                        \n\t"
 398         "cmpl %%ecx, %%ebx                      \n\t"
 399         " ja 1f                                 \n\t"
 400
 401 #if 1
 402         //athlon:4067 P3:4110
 403         "lea -0x100(%%edx), %%ecx               \n\t"
 404         "shr $31, %%ecx                         \n\t"
 405         "shl %%cl, %%edx                        \n\t"
 406         "shl %%cl, %%ebx                        \n\t"
 407 #else
 408         //athlon:4057 P3:4130
 409         "cmp $0x100, %%edx                      \n\t" //FIXME avoidable
 410         "setb %%cl                              \n\t"
 411         "shl %%cl, %%edx                        \n\t"
 412         "shl %%cl, %%ebx                        \n\t"
 413 #endif
 414         "movzbl "MANGLE(ff_h264_mps_state)"(%0), %%ecx   \n\t"
 415         "movb %%cl, (%1)                        \n\t"
 416 //eax:state ebx:low, edx:range, esi:RangeLPS
 417         "test %%bx, %%bx                        \n\t"
 418         " jnz 2f                                \n\t"
 419         "mov  "BYTE     "(%2), %%"REG_S"        \n\t"
 420         "subl $0xFFFF, %%ebx                    \n\t"
 421         "movzwl (%%"REG_S"), %%ecx              \n\t"
 422         "bswap %%ecx                            \n\t"
 423         "shrl $15, %%ecx                        \n\t"
 424         "add  $2, %%"REG_S"                     \n\t"
 425         "addl %%ecx, %%ebx                      \n\t"
 426         "mov  %%"REG_S", "BYTE    "(%2)         \n\t"
 427         "jmp 2f                                 \n\t"
 428         "1:                                     \n\t"
 429 //eax:state ebx:low, edx:range, esi:RangeLPS
 430         "subl %%ecx, %%ebx                      \n\t"
 431         "movl %%esi, %%edx                      \n\t"
 432         "movzbl " MANGLE(ff_h264_norm_shift) "(%%esi), %%ecx   \n\t"
 433         "shll %%cl, %%ebx                       \n\t"
 434         "shll %%cl, %%edx                       \n\t"
 435         "movzbl "MANGLE(ff_h264_lps_state)"(%0), %%ecx   \n\t"
 436         "movb %%cl, (%1)                        \n\t"
 437         "add  $1, %0                            \n\t"
 438         "test %%bx, %%bx                        \n\t"
 439         " jnz 2f                                \n\t"
 440
 441         "mov  "BYTE     "(%2), %%"REG_c"        \n\t"
 442         "movzwl (%%"REG_c"), %%esi              \n\t"
 443         "bswap %%esi                            \n\t"
 444         "shrl $15, %%esi                        \n\t"
 445         "subl $0xFFFF, %%esi                    \n\t"
 446         "add  $2, %%"REG_c"                     \n\t"
 447         "mov  %%"REG_c", "BYTE    "(%2)         \n\t"
 448
 449         "leal -1(%%ebx), %%ecx                  \n\t"
 450         "xorl %%ebx, %%ecx                      \n\t"
 451         "shrl $15, %%ecx                        \n\t"
 452         "movzbl " MANGLE(ff_h264_norm_shift) "(%%ecx), %%ecx   \n\t"
 453         "neg %%ecx                              \n\t"
 454         "add $7, %%ecx                          \n\t"
 455
 456         "shll %%cl , %%esi                      \n\t"
 457         "addl %%esi, %%ebx                      \n\t"
 458         "2:                                     \n\t"
 459         "movl %%edx, "RANGE    "(%2)            \n\t"
 460         "movl %%ebx, "LOW      "(%2)            \n\t"
 461         :"=&a"(bit) //FIXME this is fragile gcc either runs out of registers or misscompiles it (for example if "+a"(bit) or "+m"(*state) is used
 462         :"r"(state), "r"(c)
 463         : "%"REG_c, "%ebx", "%edx", "%"REG_S, "memory"
 464     );
 465     bit&=1;
 466 #else /* BRANCHLESS_CABAC_DECODER */
 467
 468
 469 #if defined HAVE_FAST_CMOV
 470 #define BRANCHLESS_GET_CABAC_UPDATE(ret, cabac, statep, low, lowword, range, tmp, tmpbyte)\
 471         "mov    "tmp"       , %%ecx                                     \n\t"\
 472         "shl    $17         , "tmp"                                     \n\t"\
 473         "cmp    "low"       , "tmp"                                     \n\t"\
 474         "cmova  %%ecx       , "range"                                   \n\t"\
 475         "sbb    %%ecx       , %%ecx                                     \n\t"\
 476         "and    %%ecx       , "tmp"                                     \n\t"\
 477         "sub    "tmp"       , "low"                                     \n\t"\
 478         "xor    %%ecx       , "ret"                                     \n\t"
 479 #else /* HAVE_FAST_CMOV */
 480 #define BRANCHLESS_GET_CABAC_UPDATE(ret, cabac, statep, low, lowword, range, tmp, tmpbyte)\
 481         "mov    "tmp"       , %%ecx                                     \n\t"\
 482         "shl    $17         , "tmp"                                     \n\t"\
 483         "sub    "low"       , "tmp"                                     \n\t"\
 484         "sar    $31         , "tmp"                                     \n\t" /*lps_mask*/\
 485         "sub    %%ecx       , "range"                                   \n\t" /*RangeLPS - range*/\
 486         "and    "tmp"       , "range"                                   \n\t" /*(RangeLPS - range)&lps_mask*/\
 487         "add    %%ecx       , "range"                                   \n\t" /*new range*/\
 488         "shl    $17         , %%ecx                                     \n\t"\
 489         "and    "tmp"       , %%ecx                                     \n\t"\
 490         "sub    %%ecx       , "low"                                     \n\t"\
 491         "xor    "tmp"       , "ret"                                     \n\t"
 492 #endif /* HAVE_FAST_CMOV */
 493
 494
 495 #define BRANCHLESS_GET_CABAC(ret, cabac, statep, low, lowword, range, tmp, tmpbyte)\
 496         "movzbl "statep"    , "ret"                                     \n\t"\
 497         "mov    "range"     , "tmp"                                     \n\t"\
 498         "and    $0xC0       , "range"                                   \n\t"\
 499         "movzbl "MANGLE(ff_h264_lps_range)"("ret", "range", 2), "range" \n\t"\
 500         "sub    "range"     , "tmp"                                     \n\t"\
 501         BRANCHLESS_GET_CABAC_UPDATE(ret, cabac, statep, low, lowword, range, tmp, tmpbyte)\
 502         "movzbl " MANGLE(ff_h264_norm_shift) "("range"), %%ecx          \n\t"\
 503         "shl    %%cl        , "range"                                   \n\t"\
 504         "movzbl "MANGLE(ff_h264_mlps_state)"+128("ret"), "tmp"          \n\t"\
 505         "mov    "tmpbyte"   , "statep"                                  \n\t"\
 506         "shl    %%cl        , "low"                                     \n\t"\
 507         "test   "lowword"   , "lowword"                                 \n\t"\
 508         " jnz   1f                                                      \n\t"\
 509         "mov "BYTE"("cabac"), %%"REG_c"                                 \n\t"\
 510         "movzwl (%%"REG_c")     , "tmp"                                 \n\t"\
 511         "bswap  "tmp"                                                   \n\t"\
 512         "shr    $15         , "tmp"                                     \n\t"\
 513         "sub    $0xFFFF     , "tmp"                                     \n\t"\
 514         "add    $2          , %%"REG_c"                                 \n\t"\
 515         "mov    %%"REG_c"   , "BYTE    "("cabac")                       \n\t"\
 516         "lea    -1("low")   , %%ecx                                     \n\t"\
 517         "xor    "low"       , %%ecx                                     \n\t"\
 518         "shr    $15         , %%ecx                                     \n\t"\
 519         "movzbl " MANGLE(ff_h264_norm_shift) "(%%ecx), %%ecx            \n\t"\
 520         "neg    %%ecx                                                   \n\t"\
 521         "add    $7          , %%ecx                                     \n\t"\
 522         "shl    %%cl        , "tmp"                                     \n\t"\
 523         "add    "tmp"       , "low"                                     \n\t"\
 524         "1:                                                             \n\t"
 525
 526     asm volatile(
 527         "movl "RANGE    "(%2), %%esi            \n\t"
 528         "movl "LOW      "(%2), %%ebx            \n\t"
 529         BRANCHLESS_GET_CABAC("%0", "%2", "(%1)", "%%ebx", "%%bx", "%%esi", "%%edx", "%%dl")
 530         "movl %%esi, "RANGE    "(%2)            \n\t"
 531         "movl %%ebx, "LOW      "(%2)            \n\t"
 532
 533         :"=&a"(bit)
 534         :"r"(state), "r"(c)
 535         : "%"REG_c, "%ebx", "%edx", "%esi", "memory"
 536     );
 537     bit&=1;
 538 #endif /* BRANCHLESS_CABAC_DECODER */
 539 #else /* defined(ARCH_X86) && defined(CONFIG_7REGS) && defined(HAVE_EBX_AVAILABLE) && !defined(BROKEN_RELOCATIONS) */
 540     int s = *state;
 541     int RangeLPS= ff_h264_lps_range[2*(c->range&0xC0) + s];
 542     int bit, lps_mask av_unused;
 543
 544     c->range -= RangeLPS;
 545 #ifndef BRANCHLESS_CABAC_DECODER
 546     if(c->low < (c->range<<(CABAC_BITS+1))){
 547         bit= s&1;
 548         *state= ff_h264_mps_state[s];
 549         renorm_cabac_decoder_once(c);
 550     }else{
 551         bit= ff_h264_norm_shift[RangeLPS];
 552         c->low -= (c->range<<(CABAC_BITS+1));
 553         *state= ff_h264_lps_state[s];
 554         c->range = RangeLPS<<bit;
 555         c->low <<= bit;
 556         bit= (s&1)^1;
 557
 558         if(!(c->low & CABAC_MASK)){
 559             refill2(c);
 560         }
 561     }
 562 #else /* BRANCHLESS_CABAC_DECODER */
 563     lps_mask= ((c->range<<(CABAC_BITS+1)) - c->low)>>31;
 564
 565     c->low -= (c->range<<(CABAC_BITS+1)) & lps_mask;
 566     c->range += (RangeLPS - c->range) & lps_mask;
 567
 568     s^=lps_mask;
 569     *state= (ff_h264_mlps_state+128)[s];
 570     bit= s&1;
 571
 572     lps_mask= ff_h264_norm_shift[c->range];
 573     c->range<<= lps_mask;
 574     c->low  <<= lps_mask;
 575     if(!(c->low & CABAC_MASK))
 576         refill2(c);
 577 #endif /* BRANCHLESS_CABAC_DECODER */
 578 #endif /* defined(ARCH_X86) && defined(CONFIG_7REGS) && defined(HAVE_EBX_AVAILABLE) && !defined(BROKEN_RELOCATIONS) */
 579     return bit;
 580 }
 581
 582 static int av_noinline get_cabac_noinline(CABACContext *c, uint8_t * const state){
 583     return get_cabac_inline(c,state);
 584 }
 585
 586 static int get_cabac(CABACContext *c, uint8_t * const state){
 587     return get_cabac_inline(c,state);
 588 }
 589
 590 static int get_cabac_bypass(CABACContext *c){
 591 #if 0 //not faster
 592     int bit;
 593     asm volatile(
 594         "movl "RANGE    "(%1), %%ebx            \n\t"
 595         "movl "LOW      "(%1), %%eax            \n\t"
 596         "shl $17, %%ebx                         \n\t"
 597         "add %%eax, %%eax                       \n\t"
 598         "sub %%ebx, %%eax                       \n\t"
 599         "cdq                                    \n\t"
 600         "and %%edx, %%ebx                       \n\t"
 601         "add %%ebx, %%eax                       \n\t"
 602         "test %%ax, %%ax                        \n\t"
 603         " jnz 1f                                \n\t"
 604         "movl "BYTE     "(%1), %%"REG_b"        \n\t"
 605         "subl $0xFFFF, %%eax                    \n\t"
 606         "movzwl (%%"REG_b"), %%ecx              \n\t"
 607         "bswap %%ecx                            \n\t"
 608         "shrl $15, %%ecx                        \n\t"
 609         "addl $2, %%"REG_b"                     \n\t"
 610         "addl %%ecx, %%eax                      \n\t"
 611         "movl %%"REG_b", "BYTE     "(%1)        \n\t"
 612         "1:                                     \n\t"
 613         "movl %%eax, "LOW      "(%1)            \n\t"
 614
 615         :"=&d"(bit)
 616         :"r"(c)
 617         : "%eax", "%"REG_b, "%ecx", "memory"
 618     );
 619     return bit+1;
 620 #else
 621     int range;
 622     c->low += c->low;
 623
 624     if(!(c->low & CABAC_MASK))
 625         refill(c);
 626
 627     range= c->range<<(CABAC_BITS+1);
 628     if(c->low < range){
 629         return 0;
 630     }else{
 631         c->low -= range;
 632         return 1;
 633     }
 634 #endif
 635 }
 636
 637
 638 static av_always_inline int get_cabac_bypass_sign(CABACContext *c, int val){
 639 #if defined(ARCH_X86) && !(defined(PIC) && defined(__GNUC__))
 640     asm volatile(
 641         "movl "RANGE    "(%1), %%ebx            \n\t"
 642         "movl "LOW      "(%1), %%eax            \n\t"
 643         "shl $17, %%ebx                         \n\t"
 644         "add %%eax, %%eax                       \n\t"
 645         "sub %%ebx, %%eax                       \n\t"
 646         "cdq                                    \n\t"
 647         "and %%edx, %%ebx                       \n\t"
 648         "add %%ebx, %%eax                       \n\t"
 649         "xor %%edx, %%ecx                       \n\t"
 650         "sub %%edx, %%ecx                       \n\t"
 651         "test %%ax, %%ax                        \n\t"
 652         " jnz 1f                                \n\t"
 653         "mov  "BYTE     "(%1), %%"REG_b"        \n\t"
 654         "subl $0xFFFF, %%eax                    \n\t"
 655         "movzwl (%%"REG_b"), %%edx              \n\t"
 656         "bswap %%edx                            \n\t"
 657         "shrl $15, %%edx                        \n\t"
 658         "add  $2, %%"REG_b"                     \n\t"
 659         "addl %%edx, %%eax                      \n\t"
 660         "mov  %%"REG_b", "BYTE     "(%1)        \n\t"
 661         "1:                                     \n\t"
 662         "movl %%eax, "LOW      "(%1)            \n\t"
 663
 664         :"+c"(val)
 665         :"r"(c)
 666         : "%eax", "%"REG_b, "%edx", "memory"
 667     );
 668     return val;
 669 #else
 670     int range, mask;
 671     c->low += c->low;
 672
 673     if(!(c->low & CABAC_MASK))
 674         refill(c);
 675
 676     range= c->range<<(CABAC_BITS+1);
 677     c->low -= range;
 678     mask= c->low >> 31;
 679     range &= mask;
 680     c->low += range;
 681     return (val^mask)-mask;
 682 #endif
 683 }
 684
 685 //FIXME the x86 code from this file should be moved into i386/h264 or cabac something.c/h (note ill kill you if you move my code away from under my fingers before iam finished with it!)
 686 //FIXME use some macros to avoid duplicatin get_cabac (cant be done yet as that would make optimization work hard)
 687 #if defined(ARCH_X86) && defined(CONFIG_7REGS) && defined(HAVE_EBX_AVAILABLE) && !defined(BROKEN_RELOCATIONS)
 688 static int decode_significance_x86(CABACContext *c, int max_coeff, uint8_t *significant_coeff_ctx_base, int *index){
 689     void *end= significant_coeff_ctx_base + max_coeff - 1;
 690     int minusstart= -(int)significant_coeff_ctx_base;
 691     int minusindex= 4-(int)index;
 692     int coeff_count;
 693     asm volatile(
 694         "movl "RANGE    "(%3), %%esi            \n\t"
 695         "movl "LOW      "(%3), %%ebx            \n\t"
 696
 697         "2:                                     \n\t"
 698
 699         BRANCHLESS_GET_CABAC("%%edx", "%3", "(%1)", "%%ebx", "%%bx", "%%esi", "%%eax", "%%al")
 700
 701         "test $1, %%edx                         \n\t"
 702         " jz 3f                                 \n\t"
 703
 704         BRANCHLESS_GET_CABAC("%%edx", "%3", "61(%1)", "%%ebx", "%%bx", "%%esi", "%%eax", "%%al")
 705
 706         "mov  %2, %%"REG_a"                     \n\t"
 707         "movl %4, %%ecx                         \n\t"
 708         "add  %1, %%"REG_c"                     \n\t"
 709         "movl %%ecx, (%%"REG_a")                \n\t"
 710
 711         "test $1, %%edx                         \n\t"
 712         " jnz 4f                                \n\t"
 713
 714         "add  $4, %%"REG_a"                     \n\t"
 715         "mov  %%"REG_a", %2                     \n\t"
 716
 717         "3:                                     \n\t"
 718         "add  $1, %1                            \n\t"
 719         "cmp  %5, %1                            \n\t"
 720         " jb 2b                                 \n\t"
 721         "mov  %2, %%"REG_a"                     \n\t"
 722         "movl %4, %%ecx                         \n\t"
 723         "add  %1, %%"REG_c"                     \n\t"
 724         "movl %%ecx, (%%"REG_a")                \n\t"
 725         "4:                                     \n\t"
 726         "add  %6, %%eax                         \n\t"
 727         "shr $2, %%eax                          \n\t"
 728
 729         "movl %%esi, "RANGE    "(%3)            \n\t"
 730         "movl %%ebx, "LOW      "(%3)            \n\t"
 731         :"=&a"(coeff_count), "+r"(significant_coeff_ctx_base), "+m"(index)\
 732         :"r"(c), "m"(minusstart), "m"(end), "m"(minusindex)\
 733         : "%"REG_c, "%ebx", "%edx", "%esi", "memory"\
 734     );
 735     return coeff_count;
 736 }
 737
 738 static int decode_significance_8x8_x86(CABACContext *c, uint8_t *significant_coeff_ctx_base, int *index, uint8_t *sig_off){
 739     int minusindex= 4-(int)index;
 740     int coeff_count;
 741     long last=0;
 742     asm volatile(
 743         "movl "RANGE    "(%3), %%esi            \n\t"
 744         "movl "LOW      "(%3), %%ebx            \n\t"
 745
 746         "mov %1, %%"REG_D"                      \n\t"
 747         "2:                                     \n\t"
 748
 749         "mov %6, %%"REG_a"                      \n\t"
 750         "movzbl (%%"REG_a", %%"REG_D"), %%edi   \n\t"
 751         "add %5, %%"REG_D"                      \n\t"
 752
 753         BRANCHLESS_GET_CABAC("%%edx", "%3", "(%%"REG_D")", "%%ebx", "%%bx", "%%esi", "%%eax", "%%al")
 754
 755         "mov %1, %%edi                          \n\t"
 756         "test $1, %%edx                         \n\t"
 757         " jz 3f                                 \n\t"
 758
 759         "movzbl "MANGLE(last_coeff_flag_offset_8x8)"(%%edi), %%edi\n\t"
 760         "add %5, %%"REG_D"                      \n\t"
 761
 762         BRANCHLESS_GET_CABAC("%%edx", "%3", "15(%%"REG_D")", "%%ebx", "%%bx", "%%esi", "%%eax", "%%al")
 763
 764         "mov %2, %%"REG_a"                      \n\t"
 765         "mov %1, %%edi                          \n\t"
 766         "movl %%edi, (%%"REG_a")                \n\t"
 767
 768         "test $1, %%edx                         \n\t"
 769         " jnz 4f                                \n\t"
 770
 771         "add $4, %%"REG_a"                      \n\t"
 772         "mov %%"REG_a", %2                      \n\t"
 773
 774         "3:                                     \n\t"
 775         "addl $1, %%edi                         \n\t"
 776         "mov %%edi, %1                          \n\t"
 777         "cmpl $63, %%edi                        \n\t"
 778         " jb 2b                                 \n\t"
 779         "mov %2, %%"REG_a"                      \n\t"
 780         "movl %%edi, (%%"REG_a")                \n\t"
 781         "4:                                     \n\t"
 782         "addl %4, %%eax                         \n\t"
 783         "shr $2, %%eax                          \n\t"
 784
 785         "movl %%esi, "RANGE    "(%3)            \n\t"
 786         "movl %%ebx, "LOW      "(%3)            \n\t"
 787         :"=&a"(coeff_count),"+m"(last), "+m"(index)\
 788         :"r"(c), "m"(minusindex), "m"(significant_coeff_ctx_base), "m"(sig_off)\
 789         : "%"REG_c, "%ebx", "%edx", "%esi", "%"REG_D, "memory"\
 790     );
 791     return coeff_count;
 792 }
 793 #endif /* defined(ARCH_X86) && && defined(CONFIG_7REGS) && defined(HAVE_EBX_AVAILABLE) && !defined(BROKEN_RELOCATIONS) */
 794
 795 /**
 796  *
 797  * @return the number of bytes read or 0 if no end
 798  */
 799 static int get_cabac_terminate(CABACContext *c){
 800     c->range -= 2;
 801     if(c->low < c->range<<(CABAC_BITS+1)){
 802         renorm_cabac_decoder_once(c);
 803         return 0;
 804     }else{
 805         return c->bytestream - c->bytestream_start;
 806     }
 807 }
 808
 809 /**
 810  * get (truncated) unnary binarization.
 811  */
 812 static int get_cabac_u(CABACContext *c, uint8_t * state, int max, int max_index, int truncated){
 813     int i;
 814
 815     for(i=0; i<max; i++){
 816         if(get_cabac(c, state)==0)
 817             return i;
 818
 819         if(i< max_index) state++;
 820     }
 821
 822     return truncated ? max : -1;
 823 }
 824
 825 /**
 826  * get unary exp golomb k-th order binarization.
 827  */
 828 static int get_cabac_ueg(CABACContext *c, uint8_t * state, int max, int is_signed, int k, int max_index){
 829     int i, v;
 830     int m= 1<<k;
 831
 832     if(get_cabac(c, state)==0)
 833         return 0;
 834
 835     if(0 < max_index) state++;
 836
 837     for(i=1; i<max; i++){
 838         if(get_cabac(c, state)==0){
 839             if(is_signed && get_cabac_bypass(c)){
 840                 return -i;
 841             }else
 842                 return i;
 843         }
 844
 845         if(i < max_index) state++;
 846     }
 847
 848     while(get_cabac_bypass(c)){
 849         i+= m;
 850         m+= m;
 851     }
 852
 853     v=0;
 854     while(m>>=1){
 855         v+= v + get_cabac_bypass(c);
 856     }
 857     i += v;
 858
 859     if(is_signed && get_cabac_bypass(c)){
 860         return -i;
 861     }else
 862         return i;
 863 }
 864
 865 #endif /* CABAC_H */