src/third_party/libvpx/source/libvpx/vp9/decoder/vp9_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 #include "vpx_mem/vpx_mem.h"
  12 #include "vpx_ports/mem.h"
  13
  14 #include "vp9/common/vp9_blockd.h"
  15 #include "vp9/common/vp9_common.h"
  16
  17 #include "vp9/decoder/vp9_detokenize.h"
  18
  19 #define EOB_CONTEXT_NODE            0
  20 #define ZERO_CONTEXT_NODE           1
  21 #define ONE_CONTEXT_NODE            2
  22 #define LOW_VAL_CONTEXT_NODE        0
  23 #define TWO_CONTEXT_NODE            1
  24 #define THREE_CONTEXT_NODE          2
  25 #define HIGH_LOW_CONTEXT_NODE       3
  26 #define CAT_ONE_CONTEXT_NODE        4
  27 #define CAT_THREEFOUR_CONTEXT_NODE  5
  28 #define CAT_THREE_CONTEXT_NODE      6
  29 #define CAT_FIVE_CONTEXT_NODE       7
  30
  31 #define CAT1_MIN_VAL    5
  32 #define CAT2_MIN_VAL    7
  33 #define CAT3_MIN_VAL   11
  34 #define CAT4_MIN_VAL   19
  35 #define CAT5_MIN_VAL   35
  36 #define CAT6_MIN_VAL   67
  37 #define CAT1_PROB0    159
  38 #define CAT2_PROB0    145
  39 #define CAT2_PROB1    165
  40
  41 #define CAT3_PROB0 140
  42 #define CAT3_PROB1 148
  43 #define CAT3_PROB2 173
  44
  45 #define CAT4_PROB0 135
  46 #define CAT4_PROB1 140
  47 #define CAT4_PROB2 155
  48 #define CAT4_PROB3 176
  49
  50 #define CAT5_PROB0 130
  51 #define CAT5_PROB1 134
  52 #define CAT5_PROB2 141
  53 #define CAT5_PROB3 157
  54 #define CAT5_PROB4 180
  55
  56 static const vp9_prob cat6_prob[15] = {
  57   254, 254, 254, 252, 249, 243, 230, 196, 177, 153, 140, 133, 130, 129, 0
  58 };
  59
  60 #define INCREMENT_COUNT(token)                              \
  61   do {                                                      \
  62      if (!cm->frame_parallel_decoding_mode)                 \
  63        ++coef_counts[band][ctx][token];                     \
  64   } while (0)
  65
  66 #define WRITE_COEF_CONTINUE(val, token)                  \
  67   {                                                      \
  68     v = (val * dqv) >> dq_shift;                         \
  69     dqcoeff[scan[c]] = vp9_read_bit(r) ? -v : v;         \
  70     token_cache[scan[c]] = vp9_pt_energy_class[token];   \
  71     ++c;                                                 \
  72     ctx = get_coef_context(nb, token_cache, c);          \
  73     dqv = dq[1];                                         \
  74     continue;                                            \
  75   }
  76
  77 #define ADJUST_COEF(prob, bits_count)                   \
  78   do {                                                  \
  79     val += (vp9_read(r, prob) << bits_count);           \
  80   } while (0)
  81
  82 static int decode_coefs(VP9_COMMON *cm, const MACROBLOCKD *xd, PLANE_TYPE type,
  83                        int16_t *dqcoeff, TX_SIZE tx_size, const int16_t *dq,
  84                        int ctx, const int16_t *scan, const int16_t *nb,
  85                        vp9_reader *r) {
  86   const int max_eob = 16 << (tx_size << 1);
  87   const FRAME_CONTEXT *const fc = &cm->fc;
  88   FRAME_COUNTS *const counts = &cm->counts;
  89   const int ref = is_inter_block(&xd->mi[0]->mbmi);
  90   int band, c = 0;
  91   const vp9_prob (*coef_probs)[COEFF_CONTEXTS][UNCONSTRAINED_NODES] =
  92       fc->coef_probs[tx_size][type][ref];
  93   const vp9_prob *prob;
  94   unsigned int (*coef_counts)[COEFF_CONTEXTS][UNCONSTRAINED_NODES + 1] =
  95       counts->coef[tx_size][type][ref];
  96   unsigned int (*eob_branch_count)[COEFF_CONTEXTS] =
  97       counts->eob_branch[tx_size][type][ref];
  98   uint8_t token_cache[32 * 32];
  99   const uint8_t *cat6;
 100   const uint8_t *band_translate = get_band_translate(tx_size);
 101   const int dq_shift = (tx_size == TX_32X32);
 102   int v;
 103   int16_t dqv = dq[0];
 104
 105   while (c < max_eob) {
 106     int val;
 107     band = *band_translate++;
 108     prob = coef_probs[band][ctx];
 109     if (!cm->frame_parallel_decoding_mode)
 110       ++eob_branch_count[band][ctx];
 111     if (!vp9_read(r, prob[EOB_CONTEXT_NODE])) {
 112       INCREMENT_COUNT(EOB_MODEL_TOKEN);
 113       break;
 114     }
 115
 116     while (!vp9_read(r, prob[ZERO_CONTEXT_NODE])) {
 117       INCREMENT_COUNT(ZERO_TOKEN);
 118       dqv = dq[1];
 119       token_cache[scan[c]] = 0;
 120       ++c;
 121       if (c >= max_eob)
 122         return c;  // zero tokens at the end (no eob token)
 123       ctx = get_coef_context(nb, token_cache, c);
 124       band = *band_translate++;
 125       prob = coef_probs[band][ctx];
 126     }
 127
 128     // ONE_CONTEXT_NODE_0_
 129     if (!vp9_read(r, prob[ONE_CONTEXT_NODE])) {
 130       INCREMENT_COUNT(ONE_TOKEN);
 131       WRITE_COEF_CONTINUE(1, ONE_TOKEN);
 132     }
 133
 134     INCREMENT_COUNT(TWO_TOKEN);
 135
 136     prob = vp9_pareto8_full[prob[PIVOT_NODE] - 1];
 137
 138     if (!vp9_read(r, prob[LOW_VAL_CONTEXT_NODE])) {
 139       if (!vp9_read(r, prob[TWO_CONTEXT_NODE])) {
 140         WRITE_COEF_CONTINUE(2, TWO_TOKEN);
 141       }
 142       if (!vp9_read(r, prob[THREE_CONTEXT_NODE])) {
 143         WRITE_COEF_CONTINUE(3, THREE_TOKEN);
 144       }
 145       WRITE_COEF_CONTINUE(4, FOUR_TOKEN);
 146     }
 147
 148     if (!vp9_read(r, prob[HIGH_LOW_CONTEXT_NODE])) {
 149       if (!vp9_read(r, prob[CAT_ONE_CONTEXT_NODE])) {
 150         val = CAT1_MIN_VAL;
 151         ADJUST_COEF(CAT1_PROB0, 0);
 152         WRITE_COEF_CONTINUE(val, CATEGORY1_TOKEN);
 153       }
 154       val = CAT2_MIN_VAL;
 155       ADJUST_COEF(CAT2_PROB1, 1);
 156       ADJUST_COEF(CAT2_PROB0, 0);
 157       WRITE_COEF_CONTINUE(val, CATEGORY2_TOKEN);
 158     }
 159
 160     if (!vp9_read(r, prob[CAT_THREEFOUR_CONTEXT_NODE])) {
 161       if (!vp9_read(r, prob[CAT_THREE_CONTEXT_NODE])) {
 162         val = CAT3_MIN_VAL;
 163         ADJUST_COEF(CAT3_PROB2, 2);
 164         ADJUST_COEF(CAT3_PROB1, 1);
 165         ADJUST_COEF(CAT3_PROB0, 0);
 166         WRITE_COEF_CONTINUE(val, CATEGORY3_TOKEN);
 167       }
 168       val = CAT4_MIN_VAL;
 169       ADJUST_COEF(CAT4_PROB3, 3);
 170       ADJUST_COEF(CAT4_PROB2, 2);
 171       ADJUST_COEF(CAT4_PROB1, 1);
 172       ADJUST_COEF(CAT4_PROB0, 0);
 173       WRITE_COEF_CONTINUE(val, CATEGORY4_TOKEN);
 174     }
 175
 176     if (!vp9_read(r, prob[CAT_FIVE_CONTEXT_NODE])) {
 177       val = CAT5_MIN_VAL;
 178       ADJUST_COEF(CAT5_PROB4, 4);
 179       ADJUST_COEF(CAT5_PROB3, 3);
 180       ADJUST_COEF(CAT5_PROB2, 2);
 181       ADJUST_COEF(CAT5_PROB1, 1);
 182       ADJUST_COEF(CAT5_PROB0, 0);
 183       WRITE_COEF_CONTINUE(val, CATEGORY5_TOKEN);
 184     }
 185     val = 0;
 186     cat6 = cat6_prob;
 187     while (*cat6)
 188       val = (val << 1) | vp9_read(r, *cat6++);
 189     val += CAT6_MIN_VAL;
 190
 191     WRITE_COEF_CONTINUE(val, CATEGORY6_TOKEN);
 192   }
 193
 194   return c;
 195 }
 196
 197 int vp9_decode_block_tokens(VP9_COMMON *cm, MACROBLOCKD *xd,
 198                             int plane, int block, BLOCK_SIZE plane_bsize,
 199                             int x, int y, TX_SIZE tx_size, vp9_reader *r) {
 200   struct macroblockd_plane *const pd = &xd->plane[plane];
 201   const int ctx = get_entropy_context(tx_size, pd->above_context + x,
 202                                                pd->left_context + y);
 203   const scan_order *so = get_scan(xd, tx_size, pd->plane_type, block);
 204   const int eob = decode_coefs(cm, xd, pd->plane_type,
 205                                BLOCK_OFFSET(pd->dqcoeff, block), tx_size,
 206                                pd->dequant, ctx, so->scan, so->neighbors, r);
 207   vp9_set_contexts(xd, pd, plane_bsize, tx_size, eob > 0, x, y);
 208   return eob;
 209 }
 210
 211