vp8/decoder/detokenize.c

   1 /*
   2  *  Copyright (c) 2010 The WebM 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 "vp8/common/type_aliases.h"
  13 #include "vp8/common/blockd.h"
  14 #include "onyxd_int.h"
  15 #include "vpx_mem/vpx_mem.h"
  16 #include "vpx_ports/mem.h"
  17 #include "detokenize.h"
  18
  19 #define BOOL_DATA UINT8
  20
  21 #define OCB_X PREV_COEF_CONTEXTS * ENTROPY_NODES
  22 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};
  23 #define EOB_CONTEXT_NODE            0
  24 #define ZERO_CONTEXT_NODE           1
  25 #define ONE_CONTEXT_NODE            2
  26 #define LOW_VAL_CONTEXT_NODE        3
  27 #define TWO_CONTEXT_NODE            4
  28 #define THREE_CONTEXT_NODE          5
  29 #define HIGH_LOW_CONTEXT_NODE       6
  30 #define CAT_ONE_CONTEXT_NODE        7
  31 #define CAT_THREEFOUR_CONTEXT_NODE  8
  32 #define CAT_THREE_CONTEXT_NODE      9
  33 #define CAT_FIVE_CONTEXT_NODE       10
  34
  35 /*
  36 //the definition is put in "onyxd_int.h"
  37 typedef struct
  38 {
  39     INT16         min_val;
  40     INT16         Length;
  41     UINT8 Probs[12];
  42 } TOKENEXTRABITS;
  43 */
  44
  45 DECLARE_ALIGNED(16, static const TOKENEXTRABITS, vp8d_token_extra_bits2[MAX_ENTROPY_TOKENS]) =
  46 {
  47     {  0, -1, { 0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0   } },  /* ZERO_TOKEN */
  48     {  1, 0, { 0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0   } },   /* ONE_TOKEN */
  49     {  2, 0, { 0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0   } },   /* TWO_TOKEN */
  50     {  3, 0, { 0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0   } },   /* THREE_TOKEN */
  51     {  4, 0, { 0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0   } },   /* FOUR_TOKEN */
  52     {  5, 0, { 159, 0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0   } },  /* DCT_VAL_CATEGORY1 */
  53     {  7, 1, { 145, 165, 0,  0,  0,  0,  0,  0,  0,  0,  0,  0   } }, /* DCT_VAL_CATEGORY2 */
  54     { 11, 2, { 140, 148, 173, 0,  0,  0,  0,  0,  0,  0,  0,  0   } }, /* DCT_VAL_CATEGORY3 */
  55     { 19, 3, { 135, 140, 155, 176, 0,  0,  0,  0,  0,  0,  0,  0   } }, /* DCT_VAL_CATEGORY4 */
  56     { 35, 4, { 130, 134, 141, 157, 180, 0,  0,  0,  0,  0,  0,  0   } }, /* DCT_VAL_CATEGORY5 */
  57     { 67, 10, { 129, 130, 133, 140, 153, 177, 196, 230, 243, 254, 254, 0   } }, /* DCT_VAL_CATEGORY6 */
  58     {  0, -1, { 0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0   } },  /*  EOB TOKEN */
  59 };
  60
  61
  62 void vp8_reset_mb_tokens_context(MACROBLOCKD *x)
  63 {
  64     /* Clear entropy contexts for Y2 blocks */
  65     if (x->mode_info_context->mbmi.mode != B_PRED && x->mode_info_context->mbmi.mode != SPLITMV)
  66     {
  67         vpx_memset(x->above_context, 0, sizeof(ENTROPY_CONTEXT_PLANES));
  68         vpx_memset(x->left_context, 0, sizeof(ENTROPY_CONTEXT_PLANES));
  69     }
  70     else
  71     {
  72         vpx_memset(x->above_context, 0, sizeof(ENTROPY_CONTEXT_PLANES)-1);
  73         vpx_memset(x->left_context, 0, sizeof(ENTROPY_CONTEXT_PLANES)-1);
  74     }
  75 }
  76
  77 DECLARE_ALIGNED(16, extern const unsigned char, vp8dx_bitreader_norm[256]);
  78 #define FILL \
  79     if(count < 0) \
  80         VP8DX_BOOL_DECODER_FILL(count, value, bufptr, bufend);
  81
  82 #define NORMALIZE \
  83     /*if(range < 0x80)*/                            \
  84     { \
  85         shift = vp8dx_bitreader_norm[range]; \
  86         range <<= shift; \
  87         value <<= shift; \
  88         count -= shift; \
  89     }
  90
  91 #define DECODE_AND_APPLYSIGN(value_to_sign) \
  92     split = (range + 1) >> 1; \
  93     bigsplit = (VP8_BD_VALUE)split << (VP8_BD_VALUE_SIZE - 8); \
  94     FILL \
  95     if ( value < bigsplit ) \
  96     { \
  97         range = split; \
  98         v= value_to_sign; \
  99     } \
 100     else \
 101     { \
 102         range = range-split; \
 103         value = value-bigsplit; \
 104         v = -value_to_sign; \
 105     } \
 106     range +=range;                   \
 107     value +=value;                   \
 108     count--;
 109
 110 #define DECODE_AND_BRANCH_IF_ZERO(probability,branch) \
 111     { \
 112         split = 1 +  ((( probability*(range-1) ) )>> 8); \
 113         bigsplit = (VP8_BD_VALUE)split << (VP8_BD_VALUE_SIZE - 8); \
 114         FILL \
 115         if ( value < bigsplit ) \
 116         { \
 117             range = split; \
 118             NORMALIZE \
 119             goto branch; \
 120         } \
 121         value -= bigsplit; \
 122         range = range - split; \
 123         NORMALIZE \
 124     }
 125
 126 #define DECODE_AND_LOOP_IF_ZERO(probability,branch) \
 127     { \
 128         split = 1 + ((( probability*(range-1) ) ) >> 8); \
 129         bigsplit = (VP8_BD_VALUE)split << (VP8_BD_VALUE_SIZE - 8); \
 130         FILL \
 131         if ( value < bigsplit ) \
 132         { \
 133             range = split; \
 134             NORMALIZE \
 135             Prob = coef_probs; \
 136             if(c<15) {\
 137             ++c; \
 138             Prob += vp8_coef_bands_x[c]; \
 139             goto branch; \
 140             } goto BLOCK_FINISHED; /*for malformed input */\
 141         } \
 142         value -= bigsplit; \
 143         range = range - split; \
 144         NORMALIZE \
 145     }
 146
 147 #define DECODE_SIGN_WRITE_COEFF_AND_CHECK_EXIT(val) \
 148     DECODE_AND_APPLYSIGN(val) \
 149     Prob = coef_probs + (ENTROPY_NODES*2); \
 150     if(c < 15){\
 151         qcoeff_ptr [ scan[c] ] = (INT16) v; \
 152         ++c; \
 153         goto DO_WHILE; }\
 154     qcoeff_ptr [ scan[15] ] = (INT16) v; \
 155     goto BLOCK_FINISHED;
 156
 157
 158 #define DECODE_EXTRABIT_AND_ADJUST_VAL(t,bits_count)\
 159     split = 1 +  (((range-1) * vp8d_token_extra_bits2[t].Probs[bits_count]) >> 8); \
 160     bigsplit = (VP8_BD_VALUE)split << (VP8_BD_VALUE_SIZE - 8); \
 161     FILL \
 162     if(value >= bigsplit)\
 163     {\
 164         range = range-split;\
 165         value = value-bigsplit;\
 166         val += ((UINT16)1<<bits_count);\
 167     }\
 168     else\
 169     {\
 170         range = split;\
 171     }\
 172     NORMALIZE
 173
 174 int vp8_decode_mb_tokens(VP8D_COMP *dx, MACROBLOCKD *x)
 175 {
 176     ENTROPY_CONTEXT *A = (ENTROPY_CONTEXT *)x->above_context;
 177     ENTROPY_CONTEXT *L = (ENTROPY_CONTEXT *)x->left_context;
 178     const VP8_COMMON *const oc = & dx->common;
 179
 180     BOOL_DECODER *bc = x->current_bc;
 181
 182     char *eobs = x->eobs;
 183
 184     ENTROPY_CONTEXT *a;
 185     ENTROPY_CONTEXT *l;
 186     int i;
 187
 188     int eobtotal = 0;
 189
 190     register int count;
 191
 192     const BOOL_DATA *bufptr;
 193     const BOOL_DATA *bufend;
 194     register unsigned int range;
 195     VP8_BD_VALUE value;
 196     const int *scan;
 197     register unsigned int shift;
 198     UINT32 split;
 199     VP8_BD_VALUE bigsplit;
 200     INT16 *qcoeff_ptr;
 201
 202     const vp8_prob *coef_probs;
 203     int type;
 204     int stop;
 205     INT16 val, bits_count;
 206     INT16 c;
 207     INT16 v;
 208     const vp8_prob *Prob;
 209
 210     type = 3;
 211     i = 0;
 212     stop = 16;
 213
 214     scan = vp8_default_zig_zag1d;
 215     qcoeff_ptr = &x->qcoeff[0];
 216
 217     if (x->mode_info_context->mbmi.mode != B_PRED && x->mode_info_context->mbmi.mode != SPLITMV)
 218     {
 219         i = 24;
 220         stop = 24;
 221         type = 1;
 222         qcoeff_ptr += 24*16;
 223         eobtotal -= 16;
 224     }
 225
 226     bufend  = bc->user_buffer_end;
 227     bufptr  = bc->user_buffer;
 228     value   = bc->value;
 229     count   = bc->count;
 230     range   = bc->range;
 231
 232
 233     coef_probs = oc->fc.coef_probs [type] [ 0 ] [0];
 234
 235 BLOCK_LOOP:
 236     a = A + vp8_block2above[i];
 237     l = L + vp8_block2left[i];
 238
 239     c = (INT16)(!type);
 240
 241     /*Dest = ((A)!=0) + ((B)!=0);*/
 242     VP8_COMBINEENTROPYCONTEXTS(v, *a, *l);
 243     Prob = coef_probs;
 244     Prob += v * ENTROPY_NODES;
 245
 246 DO_WHILE:
 247     Prob += vp8_coef_bands_x[c];
 248     DECODE_AND_BRANCH_IF_ZERO(Prob[EOB_CONTEXT_NODE], BLOCK_FINISHED);
 249
 250 CHECK_0_:
 251     DECODE_AND_LOOP_IF_ZERO(Prob[ZERO_CONTEXT_NODE], CHECK_0_);
 252     DECODE_AND_BRANCH_IF_ZERO(Prob[ONE_CONTEXT_NODE], ONE_CONTEXT_NODE_0_);
 253     DECODE_AND_BRANCH_IF_ZERO(Prob[LOW_VAL_CONTEXT_NODE], LOW_VAL_CONTEXT_NODE_0_);
 254     DECODE_AND_BRANCH_IF_ZERO(Prob[HIGH_LOW_CONTEXT_NODE], HIGH_LOW_CONTEXT_NODE_0_);
 255     DECODE_AND_BRANCH_IF_ZERO(Prob[CAT_THREEFOUR_CONTEXT_NODE], CAT_THREEFOUR_CONTEXT_NODE_0_);
 256     DECODE_AND_BRANCH_IF_ZERO(Prob[CAT_FIVE_CONTEXT_NODE], CAT_FIVE_CONTEXT_NODE_0_);
 257     val = vp8d_token_extra_bits2[DCT_VAL_CATEGORY6].min_val;
 258     bits_count = vp8d_token_extra_bits2[DCT_VAL_CATEGORY6].Length;
 259
 260     do
 261     {
 262         DECODE_EXTRABIT_AND_ADJUST_VAL(DCT_VAL_CATEGORY6, bits_count);
 263         bits_count -- ;
 264     }
 265     while (bits_count >= 0);
 266
 267     DECODE_SIGN_WRITE_COEFF_AND_CHECK_EXIT(val);
 268
 269 CAT_FIVE_CONTEXT_NODE_0_:
 270     val = vp8d_token_extra_bits2[DCT_VAL_CATEGORY5].min_val;
 271     DECODE_EXTRABIT_AND_ADJUST_VAL(DCT_VAL_CATEGORY5, 4);
 272     DECODE_EXTRABIT_AND_ADJUST_VAL(DCT_VAL_CATEGORY5, 3);
 273     DECODE_EXTRABIT_AND_ADJUST_VAL(DCT_VAL_CATEGORY5, 2);
 274     DECODE_EXTRABIT_AND_ADJUST_VAL(DCT_VAL_CATEGORY5, 1);
 275     DECODE_EXTRABIT_AND_ADJUST_VAL(DCT_VAL_CATEGORY5, 0);
 276     DECODE_SIGN_WRITE_COEFF_AND_CHECK_EXIT(val);
 277
 278 CAT_THREEFOUR_CONTEXT_NODE_0_:
 279     DECODE_AND_BRANCH_IF_ZERO(Prob[CAT_THREE_CONTEXT_NODE], CAT_THREE_CONTEXT_NODE_0_);
 280     val = vp8d_token_extra_bits2[DCT_VAL_CATEGORY4].min_val;
 281     DECODE_EXTRABIT_AND_ADJUST_VAL(DCT_VAL_CATEGORY4, 3);
 282     DECODE_EXTRABIT_AND_ADJUST_VAL(DCT_VAL_CATEGORY4, 2);
 283     DECODE_EXTRABIT_AND_ADJUST_VAL(DCT_VAL_CATEGORY4, 1);
 284     DECODE_EXTRABIT_AND_ADJUST_VAL(DCT_VAL_CATEGORY4, 0);
 285     DECODE_SIGN_WRITE_COEFF_AND_CHECK_EXIT(val);
 286
 287 CAT_THREE_CONTEXT_NODE_0_:
 288     val = vp8d_token_extra_bits2[DCT_VAL_CATEGORY3].min_val;
 289     DECODE_EXTRABIT_AND_ADJUST_VAL(DCT_VAL_CATEGORY3, 2);
 290     DECODE_EXTRABIT_AND_ADJUST_VAL(DCT_VAL_CATEGORY3, 1);
 291     DECODE_EXTRABIT_AND_ADJUST_VAL(DCT_VAL_CATEGORY3, 0);
 292     DECODE_SIGN_WRITE_COEFF_AND_CHECK_EXIT(val);
 293
 294 HIGH_LOW_CONTEXT_NODE_0_:
 295     DECODE_AND_BRANCH_IF_ZERO(Prob[CAT_ONE_CONTEXT_NODE], CAT_ONE_CONTEXT_NODE_0_);
 296
 297     val = vp8d_token_extra_bits2[DCT_VAL_CATEGORY2].min_val;
 298     DECODE_EXTRABIT_AND_ADJUST_VAL(DCT_VAL_CATEGORY2, 1);
 299     DECODE_EXTRABIT_AND_ADJUST_VAL(DCT_VAL_CATEGORY2, 0);
 300     DECODE_SIGN_WRITE_COEFF_AND_CHECK_EXIT(val);
 301
 302 CAT_ONE_CONTEXT_NODE_0_:
 303     val = vp8d_token_extra_bits2[DCT_VAL_CATEGORY1].min_val;
 304     DECODE_EXTRABIT_AND_ADJUST_VAL(DCT_VAL_CATEGORY1, 0);
 305     DECODE_SIGN_WRITE_COEFF_AND_CHECK_EXIT(val);
 306
 307 LOW_VAL_CONTEXT_NODE_0_:
 308     DECODE_AND_BRANCH_IF_ZERO(Prob[TWO_CONTEXT_NODE], TWO_CONTEXT_NODE_0_);
 309     DECODE_AND_BRANCH_IF_ZERO(Prob[THREE_CONTEXT_NODE], THREE_CONTEXT_NODE_0_);
 310     DECODE_SIGN_WRITE_COEFF_AND_CHECK_EXIT(4);
 311
 312 THREE_CONTEXT_NODE_0_:
 313     DECODE_SIGN_WRITE_COEFF_AND_CHECK_EXIT(3);
 314
 315 TWO_CONTEXT_NODE_0_:
 316     DECODE_SIGN_WRITE_COEFF_AND_CHECK_EXIT(2);
 317
 318 ONE_CONTEXT_NODE_0_:
 319     DECODE_AND_APPLYSIGN(1);
 320     Prob = coef_probs + ENTROPY_NODES;
 321
 322     if (c < 15)
 323     {
 324         qcoeff_ptr [ scan[c] ] = (INT16) v;
 325         ++c;
 326         goto DO_WHILE;
 327     }
 328
 329     qcoeff_ptr [ scan[15] ] = (INT16) v;
 330 BLOCK_FINISHED:
 331     *a = *l = ((eobs[i] = c) != !type);   /* any nonzero data? */
 332     eobtotal += c;
 333     qcoeff_ptr += 16;
 334
 335     i++;
 336
 337     if (i < stop)
 338         goto BLOCK_LOOP;
 339
 340     if (i == 25)
 341     {
 342         type = 0;
 343         i = 0;
 344         stop = 16;
 345         coef_probs = oc->fc.coef_probs [type] [ 0 ] [0];
 346         qcoeff_ptr -= (24*16 + 16);
 347         goto BLOCK_LOOP;
 348     }
 349
 350     if (i == 16)
 351     {
 352         type = 2;
 353         coef_probs = oc->fc.coef_probs [type] [ 0 ] [0];
 354         stop = 24;
 355         goto BLOCK_LOOP;
 356     }
 357
 358     FILL
 359     bc->user_buffer = bufptr;
 360     bc->value = value;
 361     bc->count = count;
 362     bc->range = range;
 363     return eobtotal;
 364
 365 }