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 "vp8/common/blockd.h"
12 #include "onyxd_int.h"
13 #include "vpx_mem/vpx_mem.h"
14 #include "vpx_ports/compiler_attributes.h"
15 #include "vpx_ports/mem.h"
16 #include "detokenize.h"
17
vp8_reset_mb_tokens_context(MACROBLOCKD * x)18 void vp8_reset_mb_tokens_context(MACROBLOCKD *x) {
19 ENTROPY_CONTEXT *a_ctx = ((ENTROPY_CONTEXT *)x->above_context);
20 ENTROPY_CONTEXT *l_ctx = ((ENTROPY_CONTEXT *)x->left_context);
21
22 memset(a_ctx, 0, sizeof(ENTROPY_CONTEXT_PLANES) - 1);
23 memset(l_ctx, 0, sizeof(ENTROPY_CONTEXT_PLANES) - 1);
24
25 /* Clear entropy contexts for Y2 blocks */
26 if (!x->mode_info_context->mbmi.is_4x4) {
27 a_ctx[8] = l_ctx[8] = 0;
28 }
29 }
30
31 /*
32 ------------------------------------------------------------------------------
33 Residual decoding (Paragraph 13.2 / 13.3)
34 */
35 static const uint8_t kBands[16 + 1] = {
36 0, 1, 2, 3, 6, 4, 5, 6, 6,
37 6, 6, 6, 6, 6, 6, 7, 0 /* extra entry as sentinel */
38 };
39
40 static const uint8_t kCat3[] = { 173, 148, 140, 0 };
41 static const uint8_t kCat4[] = { 176, 155, 140, 135, 0 };
42 static const uint8_t kCat5[] = { 180, 157, 141, 134, 130, 0 };
43 static const uint8_t kCat6[] = { 254, 254, 243, 230, 196, 177,
44 153, 140, 133, 130, 129, 0 };
45 static const uint8_t *const kCat3456[] = { kCat3, kCat4, kCat5, kCat6 };
46 static const uint8_t kZigzag[16] = { 0, 1, 4, 8, 5, 2, 3, 6,
47 9, 12, 13, 10, 7, 11, 14, 15 };
48
49 #define VP8GetBit vp8dx_decode_bool
50 #define NUM_PROBAS 11
51 #define NUM_CTX 3
52
53 /* for const-casting */
54 typedef const uint8_t (*ProbaArray)[NUM_CTX][NUM_PROBAS];
55
56 // With corrupt / fuzzed streams the calculation of br->value may overflow. See
57 // b/148271109.
GetSigned(BOOL_DECODER * br,int value_to_sign)58 static VPX_NO_UNSIGNED_OVERFLOW_CHECK int GetSigned(BOOL_DECODER *br,
59 int value_to_sign) {
60 int split = (br->range + 1) >> 1;
61 VP8_BD_VALUE bigsplit = (VP8_BD_VALUE)split << (VP8_BD_VALUE_SIZE - 8);
62 int v;
63
64 if (br->count < 0) vp8dx_bool_decoder_fill(br);
65
66 if (br->value < bigsplit) {
67 br->range = split;
68 v = value_to_sign;
69 } else {
70 br->range = br->range - split;
71 br->value = br->value - bigsplit;
72 v = -value_to_sign;
73 }
74 br->range += br->range;
75 br->value += br->value;
76 br->count--;
77
78 return v;
79 }
80 /*
81 Returns the position of the last non-zero coeff plus one
82 (and 0 if there's no coeff at all)
83 */
GetCoeffs(BOOL_DECODER * br,ProbaArray prob,int ctx,int n,int16_t * out)84 static int GetCoeffs(BOOL_DECODER *br, ProbaArray prob, int ctx, int n,
85 int16_t *out) {
86 const uint8_t *p = prob[n][ctx];
87 if (!VP8GetBit(br, p[0])) { /* first EOB is more a 'CBP' bit. */
88 return 0;
89 }
90 while (1) {
91 ++n;
92 if (!VP8GetBit(br, p[1])) {
93 p = prob[kBands[n]][0];
94 } else { /* non zero coeff */
95 int v, j;
96 if (!VP8GetBit(br, p[2])) {
97 p = prob[kBands[n]][1];
98 v = 1;
99 } else {
100 if (!VP8GetBit(br, p[3])) {
101 if (!VP8GetBit(br, p[4])) {
102 v = 2;
103 } else {
104 v = 3 + VP8GetBit(br, p[5]);
105 }
106 } else {
107 if (!VP8GetBit(br, p[6])) {
108 if (!VP8GetBit(br, p[7])) {
109 v = 5 + VP8GetBit(br, 159);
110 } else {
111 v = 7 + 2 * VP8GetBit(br, 165);
112 v += VP8GetBit(br, 145);
113 }
114 } else {
115 const uint8_t *tab;
116 const int bit1 = VP8GetBit(br, p[8]);
117 const int bit0 = VP8GetBit(br, p[9 + bit1]);
118 const int cat = 2 * bit1 + bit0;
119 v = 0;
120 for (tab = kCat3456[cat]; *tab; ++tab) {
121 v += v + VP8GetBit(br, *tab);
122 }
123 v += 3 + (8 << cat);
124 }
125 }
126 p = prob[kBands[n]][2];
127 }
128 j = kZigzag[n - 1];
129
130 out[j] = GetSigned(br, v);
131
132 if (n == 16 || !VP8GetBit(br, p[0])) { /* EOB */
133 return n;
134 }
135 }
136 if (n == 16) {
137 return 16;
138 }
139 }
140 }
141
vp8_decode_mb_tokens(VP8D_COMP * dx,MACROBLOCKD * x)142 int vp8_decode_mb_tokens(VP8D_COMP *dx, MACROBLOCKD *x) {
143 BOOL_DECODER *bc = x->current_bc;
144 const FRAME_CONTEXT *const fc = &dx->common.fc;
145 char *eobs = x->eobs;
146
147 int i;
148 int nonzeros;
149 int eobtotal = 0;
150
151 short *qcoeff_ptr;
152 ProbaArray coef_probs;
153 ENTROPY_CONTEXT *a_ctx = ((ENTROPY_CONTEXT *)x->above_context);
154 ENTROPY_CONTEXT *l_ctx = ((ENTROPY_CONTEXT *)x->left_context);
155 ENTROPY_CONTEXT *a;
156 ENTROPY_CONTEXT *l;
157 int skip_dc = 0;
158
159 qcoeff_ptr = &x->qcoeff[0];
160
161 if (!x->mode_info_context->mbmi.is_4x4) {
162 a = a_ctx + 8;
163 l = l_ctx + 8;
164
165 coef_probs = fc->coef_probs[1];
166
167 nonzeros = GetCoeffs(bc, coef_probs, (*a + *l), 0, qcoeff_ptr + 24 * 16);
168 *a = *l = (nonzeros > 0);
169
170 eobs[24] = nonzeros;
171 eobtotal += nonzeros - 16;
172
173 coef_probs = fc->coef_probs[0];
174 skip_dc = 1;
175 } else {
176 coef_probs = fc->coef_probs[3];
177 skip_dc = 0;
178 }
179
180 for (i = 0; i < 16; ++i) {
181 a = a_ctx + (i & 3);
182 l = l_ctx + ((i & 0xc) >> 2);
183
184 nonzeros = GetCoeffs(bc, coef_probs, (*a + *l), skip_dc, qcoeff_ptr);
185 *a = *l = (nonzeros > 0);
186
187 nonzeros += skip_dc;
188 eobs[i] = nonzeros;
189 eobtotal += nonzeros;
190 qcoeff_ptr += 16;
191 }
192
193 coef_probs = fc->coef_probs[2];
194
195 a_ctx += 4;
196 l_ctx += 4;
197 for (i = 16; i < 24; ++i) {
198 a = a_ctx + ((i > 19) << 1) + (i & 1);
199 l = l_ctx + ((i > 19) << 1) + ((i & 3) > 1);
200
201 nonzeros = GetCoeffs(bc, coef_probs, (*a + *l), 0, qcoeff_ptr);
202 *a = *l = (nonzeros > 0);
203
204 eobs[i] = nonzeros;
205 eobtotal += nonzeros;
206 qcoeff_ptr += 16;
207 }
208
209 return eobtotal;
210 }
211