vp8/decoder/arm/detokenizearm_sjl.c

   1 /*
   2  *  Copyright (c) 2010 The VP8 project authors. All Rights Reserved.
   3  *
   4  *  Use of this source code is governed by a BSD-style license
   5  *  that can be found in the LICENSE file in the root of the source
   6  *  tree. An additional intellectual property rights grant can be found
   7  *  in the file PATENTS.  All contributing project authors may
   8  *  be found in the AUTHORS file in the root of the source tree.
   9  */
  10
  11
  12 #include "type_aliases.h"
  13 #include "blockd.h"
  14 #include "onyxd_int.h"
  15 #include "vpx_mem/vpx_mem.h"
  16 #include "vpx_ports/mem.h"
  17
  18 #define BR_COUNT 8
  19 #define BOOL_DATA UINT8
  20
  21 #define OCB_X PREV_COEF_CONTEXTS * ENTROPY_NODES
  22 //ALIGN16 UINT16 onyx_coef_bands_x[16] = { 0, 1*OCB_X, 2*OCB_X, 3*OCB_X, 6*OCB_X, 4*OCB_X, 5*OCB_X, 6*OCB_X, 6*OCB_X, 6*OCB_X, 6*OCB_X, 6*OCB_X, 6*OCB_X, 6*OCB_X, 6*OCB_X, 7*OCB_X};
  23 DECLARE_ALIGNED(16, UINT8, vp8_coef_bands_x[16]) = { 0, 1 * OCB_X, 2 * OCB_X, 3 * OCB_X, 6 * OCB_X, 4 * OCB_X, 5 * OCB_X, 6 * OCB_X, 6 * OCB_X, 6 * OCB_X, 6 * OCB_X, 6 * OCB_X, 6 * OCB_X, 6 * OCB_X, 6 * OCB_X, 7 * OCB_X};
  24
  25 #define EOB_CONTEXT_NODE            0
  26 #define ZERO_CONTEXT_NODE           1
  27 #define ONE_CONTEXT_NODE            2
  28 #define LOW_VAL_CONTEXT_NODE        3
  29 #define TWO_CONTEXT_NODE            4
  30 #define THREE_CONTEXT_NODE          5
  31 #define HIGH_LOW_CONTEXT_NODE       6
  32 #define CAT_ONE_CONTEXT_NODE        7
  33 #define CAT_THREEFOUR_CONTEXT_NODE  8
  34 #define CAT_THREE_CONTEXT_NODE      9
  35 #define CAT_FIVE_CONTEXT_NODE       10
  36
  37
  38
  39
  40 DECLARE_ALIGNED(16, static const TOKENEXTRABITS, vp8d_token_extra_bits2[MAX_ENTROPY_TOKENS]) =
  41 {
  42     {  0, -1, { 0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0   } },  //ZERO_TOKEN
  43     {  1, 0, { 0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0   } },   //ONE_TOKEN
  44     {  2, 0, { 0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0   } },   //TWO_TOKEN
  45     {  3, 0, { 0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0   } },   //THREE_TOKEN
  46     {  4, 0, { 0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0   } },   //FOUR_TOKEN
  47     {  5, 0, { 159, 0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0   } },  //DCT_VAL_CATEGORY1
  48     {  7, 1, { 145, 165, 0,  0,  0,  0,  0,  0,  0,  0,  0,  0   } }, //DCT_VAL_CATEGORY2
  49     { 11, 2, { 140, 148, 173, 0,  0,  0,  0,  0,  0,  0,  0,  0   } }, //DCT_VAL_CATEGORY3
  50     { 19, 3, { 135, 140, 155, 176, 0,  0,  0,  0,  0,  0,  0,  0   } }, //DCT_VAL_CATEGORY4
  51     { 35, 4, { 130, 134, 141, 157, 180, 0,  0,  0,  0,  0,  0,  0   } }, //DCT_VAL_CATEGORY5
  52     { 67, 10, { 129, 130, 133, 140, 153, 177, 196, 230, 243, 254, 254, 0   } }, //DCT_VAL_CATEGORY6
  53     {  0, -1, { 0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0   } },  // EOB TOKEN
  54 };
  55
  56 /*
  57 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  58 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  59 */
  60 DECLARE_ALIGNED(16, const UINT8, vp8_block2context_leftabove[25*3]) =
  61 {
  62     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 3, //end of vp8_block2context
  63     0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 0, 0, 1, 1, 0, 0, 1, 1, 0, //end of vp8_block2left
  64     0, 1, 2, 3, 0, 1, 2, 3, 0, 1, 2, 3, 0, 1, 2, 3, 0, 1, 0, 1, 0, 1, 0, 1, 0 //end of vp8_block2above
  65 };
  66
  67 /*
  68 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  69 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  70 */
  71
  72 void vp8_reset_mb_tokens_context(MACROBLOCKD *x)
  73 {
  74     ENTROPY_CONTEXT **const A = x->above_context;
  75     ENTROPY_CONTEXT(* const L)[4] = x->left_context;
  76
  77     ENTROPY_CONTEXT *a;
  78     ENTROPY_CONTEXT *l;
  79     int i;
  80
  81     for (i = 0; i < 24; i++)
  82     {
  83
  84         a = A[ vp8_block2context[i] ] + vp8_block2above[i];
  85         l = L[ vp8_block2context[i] ] + vp8_block2left[i];
  86
  87         *a = *l = 0;
  88     }
  89
  90     if (x->mbmi.mode != B_PRED && x->mbmi.mode != SPLITMV)
  91     {
  92         a = A[Y2CONTEXT] + vp8_block2above[24];
  93         l = L[Y2CONTEXT] + vp8_block2left[24];
  94         *a = *l = 0;
  95     }
  96
  97
  98 }
  99
 100 #define ONYXBLOCK2CONTEXT_OFFSET    0
 101 #define ONYXBLOCK2LEFT_OFFSET       25
 102 #define ONYXBLOCK2ABOVE_OFFSET 50
 103
 104 DECLARE_ALIGNED(16, const static unsigned char, norm[128]) =
 105 {
 106     0, 7, 6, 6, 5, 5, 5, 5, 4, 4, 4, 4, 4, 4, 4, 4, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
 107     2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
 108     1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
 109     1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
 110 };
 111
 112 /*
 113 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 114 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 115 */
 116 void init_detokenizer(VP8D_COMP *dx)
 117 {
 118     const VP8_COMMON *const oc = & dx->common;
 119     MACROBLOCKD *x = & dx->mb;
 120
 121     dx->detoken.norm_ptr = (unsigned char *)norm;
 122     dx->detoken.vp8_coef_tree_ptr = (vp8_tree_index *)vp8_coef_tree;
 123     dx->detoken.ptr_onyxblock2context_leftabove = (UINT8 *)vp8_block2context_leftabove;
 124     dx->detoken.ptr_onyx_coef_bands_x = vp8_coef_bands_x;
 125     dx->detoken.scan = (int *)vp8_default_zig_zag1d;
 126     dx->detoken.teb_base_ptr = (TOKENEXTRABITS *)vp8d_token_extra_bits2;
 127
 128     dx->detoken.qcoeff_start_ptr = &x->qcoeff[0];
 129
 130
 131     dx->detoken.coef_probs[0] = (unsigned char *)(oc->fc.coef_probs [0] [ 0 ] [0]);
 132     dx->detoken.coef_probs[1] = (unsigned char *)(oc->fc.coef_probs [1] [ 0 ] [0]);
 133     dx->detoken.coef_probs[2] = (unsigned char *)(oc->fc.coef_probs [2] [ 0 ] [0]);
 134     dx->detoken.coef_probs[3] = (unsigned char *)(oc->fc.coef_probs [3] [ 0 ] [0]);
 135
 136 }
 137
 138 /*
 139 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 140 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 141 */
 142
 143
 144 //shift = norm[range]; \
 145 //      shift = norm_ptr[range]; \
 146
 147 #define NORMALIZE \
 148     /*if(range < 0x80)*/                            \
 149     { \
 150         shift = detoken->norm_ptr[range]; \
 151         range <<= shift; \
 152         value <<= shift; \
 153         count -= shift; \
 154         if(count <= 0) \
 155         { \
 156             count += BR_COUNT ; \
 157             value |= (*bufptr) << (BR_COUNT-count); \
 158             bufptr++; \
 159         } \
 160     }
 161 #if 1
 162 #define DECODE_AND_APPLYSIGN(value_to_sign) \
 163     split = (range + 1) >> 1; \
 164     if ( (value >> 24) < split ) \
 165     { \
 166         range = split; \
 167         v= value_to_sign; \
 168     } \
 169     else \
 170     { \
 171         range = range-split; \
 172         value = value-(split<<24); \
 173         v = -value_to_sign; \
 174     } \
 175     range +=range;                   \
 176     value +=value;                   \
 177     if (!--count) \
 178     { \
 179         count = BR_COUNT; \
 180         value |= *bufptr; \
 181         bufptr++; \
 182     }
 183
 184 #define DECODE_AND_BRANCH_IF_ZERO(probability,branch) \
 185     { \
 186         split = 1 +  ((( probability*(range-1) ) )>> 8); \
 187         if ( (value >> 24) < split ) \
 188         { \
 189             range = split; \
 190             NORMALIZE \
 191             goto branch; \
 192         } \
 193         value -= (split<<24); \
 194         range = range - split; \
 195         NORMALIZE \
 196     }
 197
 198 #define DECODE_AND_LOOP_IF_ZERO(probability,branch) \
 199     { \
 200         split = 1 + ((( probability*(range-1) ) ) >> 8); \
 201         if ( (value >> 24) < split ) \
 202         { \
 203             range = split; \
 204             NORMALIZE \
 205             Prob = coef_probs; \
 206             ++c; \
 207             Prob += vp8_coef_bands_x[c]; \
 208             goto branch; \
 209         } \
 210         value -= (split<<24); \
 211         range = range - split; \
 212         NORMALIZE \
 213     }
 214
 215 #define DECODE_SIGN_WRITE_COEFF_AND_CHECK_EXIT(val) \
 216     DECODE_AND_APPLYSIGN(val) \
 217     Prob = coef_probs + (ENTROPY_NODES*2); \
 218     if(c < 15){\
 219         qcoeff_ptr [ scan[c] ] = (INT16) v; \
 220         ++c; \
 221         goto DO_WHILE; }\
 222     qcoeff_ptr [ scan[15] ] = (INT16) v; \
 223     goto BLOCK_FINISHED;
 224
 225
 226 #define DECODE_EXTRABIT_AND_ADJUST_VAL(t,bits_count)\
 227     split = 1 +  (((range-1) * vp8d_token_extra_bits2[t].Probs[bits_count]) >> 8); \
 228     if(value >= (split<<24))\
 229     {\
 230         range = range-split;\
 231         value = value-(split<<24);\
 232         val += ((UINT16)1<<bits_count);\
 233     }\
 234     else\
 235     {\
 236         range = split;\
 237     }\
 238     NORMALIZE
 239 #endif
 240
 241 #if 0
 242 int vp8_decode_mb_tokens(VP8D_COMP *dx, MACROBLOCKD *x)
 243 {
 244     ENTROPY_CONTEXT **const A = x->above_context;
 245     ENTROPY_CONTEXT(* const L)[4] = x->left_context;
 246     const VP8_COMMON *const oc = & dx->common;
 247
 248     BOOL_DECODER *bc = x->current_bc;
 249
 250     ENTROPY_CONTEXT *a;
 251     ENTROPY_CONTEXT *l;
 252     int i;
 253
 254     int eobtotal = 0;
 255
 256     register int count;
 257
 258     BOOL_DATA *bufptr;
 259     register unsigned int range;
 260     register unsigned int value;
 261     const int *scan;
 262     register unsigned int shift;
 263     UINT32 split;
 264     INT16 *qcoeff_ptr;
 265
 266     UINT8 *coef_probs;
 267     int type;
 268     int stop;
 269     INT16 val, bits_count;
 270     INT16 c;
 271     INT16 t;
 272     INT16 v;
 273     vp8_prob *Prob;
 274
 275     //int *scan;
 276     type = 3;
 277     i = 0;
 278     stop = 16;
 279
 280     if (x->mbmi.mode != B_PRED && x->mbmi.mode != SPLITMV)
 281     {
 282         i = 24;
 283         stop = 24;
 284         type = 1;
 285         qcoeff_ptr = &x->qcoeff[24*16];
 286         scan = vp8_default_zig_zag1d;
 287         eobtotal -= 16;
 288     }
 289     else
 290     {
 291         scan = vp8_default_zig_zag1d;
 292         qcoeff_ptr = &x->qcoeff[0];
 293     }
 294
 295     count   = bc->count;
 296     range   = bc->range;
 297     value   = bc->value;
 298     bufptr  = &bc->buffer[bc->pos];
 299
 300
 301     coef_probs = (unsigned char *)(oc->fc.coef_probs [type] [ 0 ] [0]);
 302
 303 BLOCK_LOOP:
 304     a = A[ vp8_block2context[i] ] + vp8_block2above[i];
 305     l = L[ vp8_block2context[i] ] + vp8_block2left[i];
 306     c = (INT16)(!type);
 307
 308     VP8_COMBINEENTROPYCONTEXTS(t, *a, *l);
 309     Prob = coef_probs;
 310     Prob += t * ENTROPY_NODES;
 311
 312 DO_WHILE:
 313     Prob += vp8_coef_bands_x[c];
 314     DECODE_AND_BRANCH_IF_ZERO(Prob[EOB_CONTEXT_NODE], BLOCK_FINISHED);
 315
 316 CHECK_0_:
 317     DECODE_AND_LOOP_IF_ZERO(Prob[ZERO_CONTEXT_NODE], CHECK_0_);
 318     DECODE_AND_BRANCH_IF_ZERO(Prob[ONE_CONTEXT_NODE], ONE_CONTEXT_NODE_0_);
 319     DECODE_AND_BRANCH_IF_ZERO(Prob[LOW_VAL_CONTEXT_NODE], LOW_VAL_CONTEXT_NODE_0_);
 320     DECODE_AND_BRANCH_IF_ZERO(Prob[HIGH_LOW_CONTEXT_NODE], HIGH_LOW_CONTEXT_NODE_0_);
 321     DECODE_AND_BRANCH_IF_ZERO(Prob[CAT_THREEFOUR_CONTEXT_NODE], CAT_THREEFOUR_CONTEXT_NODE_0_);
 322     DECODE_AND_BRANCH_IF_ZERO(Prob[CAT_FIVE_CONTEXT_NODE], CAT_FIVE_CONTEXT_NODE_0_);
 323     val = vp8d_token_extra_bits2[DCT_VAL_CATEGORY6].min_val;
 324     bits_count = vp8d_token_extra_bits2[DCT_VAL_CATEGORY6].Length;
 325
 326     do
 327     {
 328         DECODE_EXTRABIT_AND_ADJUST_VAL(DCT_VAL_CATEGORY6, bits_count);
 329         bits_count -- ;
 330     }
 331     while (bits_count >= 0);
 332
 333     DECODE_SIGN_WRITE_COEFF_AND_CHECK_EXIT(val);
 334
 335 CAT_FIVE_CONTEXT_NODE_0_:
 336     val = vp8d_token_extra_bits2[DCT_VAL_CATEGORY5].min_val;
 337     DECODE_EXTRABIT_AND_ADJUST_VAL(DCT_VAL_CATEGORY5, 4);
 338     DECODE_EXTRABIT_AND_ADJUST_VAL(DCT_VAL_CATEGORY5, 3);
 339     DECODE_EXTRABIT_AND_ADJUST_VAL(DCT_VAL_CATEGORY5, 2);
 340     DECODE_EXTRABIT_AND_ADJUST_VAL(DCT_VAL_CATEGORY5, 1);
 341     DECODE_EXTRABIT_AND_ADJUST_VAL(DCT_VAL_CATEGORY5, 0);
 342     DECODE_SIGN_WRITE_COEFF_AND_CHECK_EXIT(val);
 343
 344 CAT_THREEFOUR_CONTEXT_NODE_0_:
 345     DECODE_AND_BRANCH_IF_ZERO(Prob[CAT_THREE_CONTEXT_NODE], CAT_THREE_CONTEXT_NODE_0_);
 346     val = vp8d_token_extra_bits2[DCT_VAL_CATEGORY4].min_val;
 347     DECODE_EXTRABIT_AND_ADJUST_VAL(DCT_VAL_CATEGORY4, 3);
 348     DECODE_EXTRABIT_AND_ADJUST_VAL(DCT_VAL_CATEGORY4, 2);
 349     DECODE_EXTRABIT_AND_ADJUST_VAL(DCT_VAL_CATEGORY4, 1);
 350     DECODE_EXTRABIT_AND_ADJUST_VAL(DCT_VAL_CATEGORY4, 0);
 351     DECODE_SIGN_WRITE_COEFF_AND_CHECK_EXIT(val);
 352
 353 CAT_THREE_CONTEXT_NODE_0_:
 354     val = vp8d_token_extra_bits2[DCT_VAL_CATEGORY3].min_val;
 355     DECODE_EXTRABIT_AND_ADJUST_VAL(DCT_VAL_CATEGORY3, 2);
 356     DECODE_EXTRABIT_AND_ADJUST_VAL(DCT_VAL_CATEGORY3, 1);
 357     DECODE_EXTRABIT_AND_ADJUST_VAL(DCT_VAL_CATEGORY3, 0);
 358     DECODE_SIGN_WRITE_COEFF_AND_CHECK_EXIT(val);
 359
 360 HIGH_LOW_CONTEXT_NODE_0_:
 361     DECODE_AND_BRANCH_IF_ZERO(Prob[CAT_ONE_CONTEXT_NODE], CAT_ONE_CONTEXT_NODE_0_);
 362
 363     val = vp8d_token_extra_bits2[DCT_VAL_CATEGORY2].min_val;
 364     DECODE_EXTRABIT_AND_ADJUST_VAL(DCT_VAL_CATEGORY2, 1);
 365     DECODE_EXTRABIT_AND_ADJUST_VAL(DCT_VAL_CATEGORY2, 0);
 366     DECODE_SIGN_WRITE_COEFF_AND_CHECK_EXIT(val);
 367
 368 CAT_ONE_CONTEXT_NODE_0_:
 369     val = vp8d_token_extra_bits2[DCT_VAL_CATEGORY1].min_val;
 370     DECODE_EXTRABIT_AND_ADJUST_VAL(DCT_VAL_CATEGORY1, 0);
 371     DECODE_SIGN_WRITE_COEFF_AND_CHECK_EXIT(val);
 372
 373 LOW_VAL_CONTEXT_NODE_0_:
 374     DECODE_AND_BRANCH_IF_ZERO(Prob[TWO_CONTEXT_NODE], TWO_CONTEXT_NODE_0_);
 375     DECODE_AND_BRANCH_IF_ZERO(Prob[THREE_CONTEXT_NODE], THREE_CONTEXT_NODE_0_);
 376     DECODE_SIGN_WRITE_COEFF_AND_CHECK_EXIT(4);
 377
 378 THREE_CONTEXT_NODE_0_:
 379     DECODE_SIGN_WRITE_COEFF_AND_CHECK_EXIT(3);
 380
 381 TWO_CONTEXT_NODE_0_:
 382     DECODE_SIGN_WRITE_COEFF_AND_CHECK_EXIT(2);
 383
 384 ONE_CONTEXT_NODE_0_:
 385     DECODE_AND_APPLYSIGN(1);
 386     Prob = coef_probs + ENTROPY_NODES;
 387
 388     if (c < 15)
 389     {
 390         qcoeff_ptr [ scan[c] ] = (INT16) v;
 391         ++c;
 392         goto DO_WHILE;
 393     }
 394
 395     qcoeff_ptr [ scan[15] ] = (INT16) v;
 396 BLOCK_FINISHED:
 397     t = ((x->Block[i].eob = c) != !type);   // any nonzero data?
 398     eobtotal += x->Block[i].eob;
 399     *a = *l = t;
 400     qcoeff_ptr += 16;
 401
 402     i++;
 403
 404     if (i < stop)
 405         goto BLOCK_LOOP;
 406
 407     if (i == 25)
 408     {
 409         scan = vp8_default_zig_zag1d;//x->scan_order1d;
 410         type = 0;
 411         i = 0;
 412         stop = 16;
 413         coef_probs = (unsigned char *)(oc->fc.coef_probs [type] [ 0 ] [0]);
 414         qcoeff_ptr = &x->qcoeff[0];
 415         goto BLOCK_LOOP;
 416     }
 417
 418     if (i == 16)
 419     {
 420         type = 2;
 421         coef_probs = (unsigned char *)(oc->fc.coef_probs [type] [ 0 ] [0]);
 422         stop = 24;
 423         goto BLOCK_LOOP;
 424     }
 425
 426     bc->count = count;
 427     bc->value = value;
 428     bc->range = range;
 429     bc->pos  = bufptr - bc->buffer;
 430     return eobtotal;
 431
 432 }
 433 //#endif
 434 #else
 435 /*
 436 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 437 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 438 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 439 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 440 */
 441
 442 #if 0
 443 //uses relative offsets
 444
 445 const vp8_tree_index vp8_coef_tree_x[ 22] =   /* corresponding _CONTEXT_NODEs */
 446 {
 447     -DCT_EOB_TOKEN, 1,                             /* 0 = EOB */
 448     -ZERO_TOKEN, 1,                               /* 1 = ZERO */
 449     -ONE_TOKEN, 1,                               /* 2 = ONE */
 450     2, 5,                                       /* 3 = LOW_VAL */
 451     -TWO_TOKEN, 1,                         /* 4 = TWO */
 452     -THREE_TOKEN, -FOUR_TOKEN,                /* 5 = THREE */
 453     2, 3,                                  /* 6 = HIGH_LOW */
 454     -DCT_VAL_CATEGORY1, -DCT_VAL_CATEGORY2,   /* 7 = CAT_ONE */
 455     2, 3,                                 /* 8 = CAT_THREEFOUR */
 456     -DCT_VAL_CATEGORY3, -DCT_VAL_CATEGORY4,  /* 9 = CAT_THREE */
 457     -DCT_VAL_CATEGORY5, -DCT_VAL_CATEGORY6   /* 10 = CAT_FIVE */
 458 };
 459 #endif
 460
 461 #define _SCALEDOWN 8 //16 //8
 462
 463 int vp8_decode_mb_tokens_v5(DETOK *detoken, int type);
 464
 465 int vp8_decode_mb_tokens_v5_c(DETOK *detoken, int type)
 466 {
 467     BOOL_DECODER *bc = detoken->current_bc;
 468
 469     ENTROPY_CONTEXT *a;
 470     ENTROPY_CONTEXT *l;
 471     int i;
 472
 473     register int count;
 474
 475     BOOL_DATA *bufptr;
 476     register unsigned int range;
 477     register unsigned int value;
 478     register unsigned int shift;
 479     UINT32 split;
 480     INT16 *qcoeff_ptr;
 481
 482     UINT8 *coef_probs;
 483 //  int type;
 484     int stop;
 485     INT16 c;
 486     INT16 t;
 487     INT16 v;
 488     vp8_prob *Prob;
 489
 490
 491
 492 //  type = 3;
 493     i = 0;
 494     stop = 16;
 495     qcoeff_ptr = detoken->qcoeff_start_ptr;
 496
 497 //  if( detoken->mode != B_PRED && detoken->mode != SPLITMV)
 498     if (type == 1)
 499     {
 500         i += 24;
 501         stop += 8; //24;
 502 //      type = 1;
 503         qcoeff_ptr += 24 * 16;
 504 //      eobtotal-=16;
 505     }
 506
 507     count   = bc->count;
 508     range   = bc->range;
 509     value   = bc->value;
 510     bufptr  = &bc->buffer[bc->pos];
 511
 512
 513     coef_probs = detoken->coef_probs[type]; //(unsigned char *)( oc->fc.coef_probs [type] [ 0 ] [0]);
 514
 515 BLOCK_LOOP:
 516     a = detoken->A[ detoken->ptr_onyxblock2context_leftabove[i] ];
 517     l = detoken->L[ detoken->ptr_onyxblock2context_leftabove[i] ];
 518     c = !type;
 519     a += detoken->ptr_onyxblock2context_leftabove[i + ONYXBLOCK2ABOVE_OFFSET];
 520     l += detoken->ptr_onyxblock2context_leftabove[i + ONYXBLOCK2LEFT_OFFSET];
 521
 522     //#define ONYX_COMBINEENTROPYCONTEXTS( Dest, A, B) \
 523     //Dest = ((A)!=0) + ((B)!=0);
 524
 525     VP8_COMBINEENTROPYCONTEXTS(t, *a, *l);
 526
 527     Prob = coef_probs;
 528     Prob += t * ENTROPY_NODES;
 529     t = 0;
 530
 531     do
 532     {
 533
 534         {
 535 //                  onyx_tree_index * onyx_coef_tree_ptr = onyx_coef_tree_x;
 536
 537             Prob += detoken->ptr_onyx_coef_bands_x[c];
 538
 539         GET_TOKEN_START:
 540
 541             do
 542             {
 543                 split = 1 + (((range - 1) * (Prob[t>>1])) >> 8);
 544
 545                 if (value >> 24 >= split)
 546                 {
 547                     range = range - split;
 548                     value = value - (split << 24);
 549                     t += 1;
 550
 551                     //used to eliminate else branch
 552                     split = range;
 553                 }
 554
 555                 range = split;
 556
 557                 t = detoken->vp8_coef_tree_ptr[ t ];
 558
 559                 NORMALIZE
 560
 561             }
 562             while (t  > 0) ;
 563         }
 564     GET_TOKEN_STOP:
 565
 566         if (t == -DCT_EOB_TOKEN)
 567         {
 568             break;
 569         }
 570
 571         v = -t;
 572
 573         if (v > FOUR_TOKEN)
 574         {
 575             INT16 bits_count;
 576             TOKENEXTRABITS *teb_ptr;
 577
 578 //                      teb_ptr = &onyxd_token_extra_bits2[t];
 579 //                  teb_ptr = &onyxd_token_extra_bits2[v];
 580             teb_ptr = &detoken->teb_base_ptr[v];
 581
 582
 583             v = teb_ptr->min_val;
 584             bits_count = teb_ptr->Length;
 585
 586             do
 587             {
 588                 split = 1 + (((range - 1) * teb_ptr->Probs[bits_count]) >> _SCALEDOWN);
 589
 590                 if ((value >> 24) >= split)
 591                 {
 592                     range = range - split;
 593                     value = value - (split << 24);
 594                     v += ((UINT16)1 << bits_count);
 595
 596                     //used to eliminate else branch
 597                     split = range;
 598                 }
 599
 600                 range = split;
 601
 602                 NORMALIZE
 603
 604                 bits_count -- ;
 605             }
 606             while (bits_count >= 0);
 607         }
 608
 609         Prob = coef_probs;
 610
 611         if (t)
 612         {
 613             split = 1 + (((range - 1) * vp8_prob_half) >> 8);
 614
 615             if ((value >> 24) >= split)
 616             {
 617                 range = range - split;
 618                 value = value - (split << 24);
 619                 v = (v ^ -1) + 1;           /* negate w/out conditionals */
 620
 621                 //used to eliminate else branch
 622                 split = range;
 623             }
 624
 625             range = split;
 626
 627             NORMALIZE
 628             Prob += ENTROPY_NODES;
 629
 630             if (t < -ONE_TOKEN)
 631                 Prob += ENTROPY_NODES;
 632
 633             t = -2;
 634         }
 635
 636         //if t is zero, we will skip the eob table check
 637         t += 2;
 638         qcoeff_ptr [detoken->scan [c] ] = (INT16) v;
 639
 640     }
 641     while (++c < 16);
 642
 643     if (t != -DCT_EOB_TOKEN)
 644     {
 645         --c;
 646     }
 647
 648     t = ((detoken->eob[i] = c) != !type);   // any nonzero data?
 649 //  eobtotal += detoken->eob[i];
 650     *a = *l = t;
 651     qcoeff_ptr += 16;
 652
 653     i++;
 654
 655     if (i < stop)
 656         goto BLOCK_LOOP;
 657
 658     if (i == 25)
 659     {
 660         type = 0;
 661         i = 0;
 662         stop = 16;
 663 //      coef_probs = (unsigned char *)(oc->fc.coef_probs [type] [ 0 ] [0]);
 664         coef_probs = detoken->coef_probs[type]; //(unsigned char *)( oc->fc.coef_probs [type] [ 0 ] [0]);
 665         qcoeff_ptr = detoken->qcoeff_start_ptr;
 666         goto BLOCK_LOOP;
 667     }
 668
 669     if (i == 16)
 670     {
 671         type = 2;
 672 //      coef_probs =(unsigned char *)( oc->fc.coef_probs [type] [ 0 ] [0]);
 673         coef_probs = detoken->coef_probs[type]; //(unsigned char *)( oc->fc.coef_probs [type] [ 0 ] [0]);
 674         stop = 24;
 675         goto BLOCK_LOOP;
 676     }
 677
 678     bc->count = count;
 679     bc->value = value;
 680     bc->range = range;
 681     bc->pos  = bufptr - bc->buffer;
 682     return 0;
 683 }
 684 //#if 0
 685 int vp8_decode_mb_tokens(VP8D_COMP *dx, MACROBLOCKD *x)
 686 {
 687 //  const ONYX_COMMON * const oc = & dx->common;
 688     int eobtotal = 0;
 689     int i, type;
 690     /*
 691         dx->detoken.norm_ptr = norm;
 692         dx->detoken.onyx_coef_tree_ptr = onyx_coef_tree;
 693         dx->detoken.ptr_onyxblock2context_leftabove = ONYXBLOCK2CONTEXT_LEFTABOVE;
 694         dx->detoken.ptr_onyx_coef_bands_x = onyx_coef_bands_x;
 695         dx->detoken.scan = default_zig_zag1d;
 696         dx->detoken.teb_base_ptr = onyxd_token_extra_bits2;
 697
 698         dx->detoken.qcoeff_start_ptr = &x->qcoeff[0];
 699
 700         dx->detoken.A = x->above_context;
 701         dx->detoken.L = x->left_context;
 702
 703         dx->detoken.coef_probs[0] = (unsigned char *)( oc->fc.coef_probs [0] [ 0 ] [0]);
 704         dx->detoken.coef_probs[1] = (unsigned char *)( oc->fc.coef_probs [1] [ 0 ] [0]);
 705         dx->detoken.coef_probs[2] = (unsigned char *)( oc->fc.coef_probs [2] [ 0 ] [0]);
 706         dx->detoken.coef_probs[3] = (unsigned char *)( oc->fc.coef_probs [3] [ 0 ] [0]);
 707     */
 708
 709     dx->detoken.current_bc = x->current_bc;
 710     dx->detoken.A = x->above_context;
 711     dx->detoken.L = x->left_context;
 712
 713     type = 3;
 714
 715     if (x->mbmi.mode != B_PRED && x->mbmi.mode != SPLITMV)
 716     {
 717         type = 1;
 718         eobtotal -= 16;
 719     }
 720
 721     vp8_decode_mb_tokens_v5(&dx->detoken, type);
 722
 723     for (i = 0; i < 25; i++)
 724     {
 725         x->Block[i].eob = dx->detoken.eob[i];
 726         eobtotal += dx->detoken.eob[i];
 727     }
 728
 729     return eobtotal;
 730 }
 731 #endif