OLD | NEW |
1 /* | 1 /* |
2 * Copyright (c) 2010 The WebM project authors. All Rights Reserved. | 2 * Copyright (c) 2010 The WebM project authors. All Rights Reserved. |
3 * | 3 * |
4 * Use of this source code is governed by a BSD-style license | 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 | 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 | 6 * tree. An additional intellectual property rights grant can be found |
7 * in the file PATENTS. All contributing project authors may | 7 * in the file PATENTS. All contributing project authors may |
8 * be found in the AUTHORS file in the root of the source tree. | 8 * be found in the AUTHORS file in the root of the source tree. |
9 */ | 9 */ |
10 | 10 |
11 | 11 |
12 #include <math.h> | 12 #include <math.h> |
13 #include <stdio.h> | 13 #include <stdio.h> |
14 #include <string.h> | 14 #include <string.h> |
15 #include <assert.h> | 15 #include <assert.h> |
16 #include "onyx_int.h" | 16 #include "onyx_int.h" |
17 #include "tokenize.h" | 17 #include "tokenize.h" |
18 #include "vpx_mem/vpx_mem.h" | 18 #include "vpx_mem/vpx_mem.h" |
19 | 19 |
20 /* Global event counters used for accumulating statistics across several | 20 /* Global event counters used for accumulating statistics across several |
21 compressions, then generating context.c = initial stats. */ | 21 compressions, then generating context.c = initial stats. */ |
22 | 22 |
23 #ifdef ENTROPY_STATS | 23 #ifdef ENTROPY_STATS |
24 _int64 context_counters[BLOCK_TYPES] [COEF_BANDS] [PREV_COEF_CONTEXTS] [MAX_ENTR
OPY_TOKENS]; | 24 _int64 context_counters[BLOCK_TYPES] [COEF_BANDS] [PREV_COEF_CONTEXTS] [MAX_ENTR
OPY_TOKENS]; |
25 #endif | 25 #endif |
26 void vp8_stuff_mb(VP8_COMP *cpi, MACROBLOCKD *x, TOKENEXTRA **t) ; | 26 void vp8_stuff_mb(VP8_COMP *cpi, MACROBLOCK *x, TOKENEXTRA **t) ; |
27 void vp8_fix_contexts(MACROBLOCKD *x); | 27 void vp8_fix_contexts(MACROBLOCKD *x); |
28 | 28 |
29 #include "dct_value_tokens.h" | 29 #include "dct_value_tokens.h" |
30 #include "dct_value_cost.h" | 30 #include "dct_value_cost.h" |
31 | 31 |
32 const TOKENVALUE *const vp8_dct_value_tokens_ptr = dct_value_tokens + | 32 const TOKENVALUE *const vp8_dct_value_tokens_ptr = dct_value_tokens + |
33 DCT_MAX_VALUE; | 33 DCT_MAX_VALUE; |
34 const short *const vp8_dct_value_cost_ptr = dct_value_cost + DCT_MAX_VALUE; | 34 const short *const vp8_dct_value_cost_ptr = dct_value_cost + DCT_MAX_VALUE; |
35 | 35 |
36 #if 0 | 36 #if 0 |
(...skipping 58 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
95 } | 95 } |
96 while (++i < DCT_MAX_VALUE); | 96 while (++i < DCT_MAX_VALUE); |
97 | 97 |
98 vp8_dct_value_tokens_ptr = dct_value_tokens + DCT_MAX_VALUE; | 98 vp8_dct_value_tokens_ptr = dct_value_tokens + DCT_MAX_VALUE; |
99 vp8_dct_value_cost_ptr = dct_value_cost + DCT_MAX_VALUE; | 99 vp8_dct_value_cost_ptr = dct_value_cost + DCT_MAX_VALUE; |
100 } | 100 } |
101 */ | 101 */ |
102 | 102 |
103 static void tokenize2nd_order_b | 103 static void tokenize2nd_order_b |
104 ( | 104 ( |
105 MACROBLOCKD *x, | 105 MACROBLOCK *x, |
106 TOKENEXTRA **tp, | 106 TOKENEXTRA **tp, |
107 VP8_COMP *cpi | 107 VP8_COMP *cpi |
108 ) | 108 ) |
109 { | 109 { |
| 110 MACROBLOCKD *xd = &x->e_mbd; |
110 int pt; /* near block/prev token context index */ | 111 int pt; /* near block/prev token context index */ |
111 int c; /* start at DC */ | 112 int c; /* start at DC */ |
112 TOKENEXTRA *t = *tp;/* store tokens starting here */ | 113 TOKENEXTRA *t = *tp;/* store tokens starting here */ |
113 const BLOCKD *b; | 114 const BLOCKD *b; |
114 const short *qcoeff_ptr; | 115 const short *qcoeff_ptr; |
115 ENTROPY_CONTEXT * a; | 116 ENTROPY_CONTEXT * a; |
116 ENTROPY_CONTEXT * l; | 117 ENTROPY_CONTEXT * l; |
117 int band, rc, v, token; | 118 int band, rc, v, token; |
118 int eob; | 119 int eob; |
119 | 120 |
120 b = x->block + 24; | 121 b = xd->block + 24; |
121 qcoeff_ptr = b->qcoeff; | 122 qcoeff_ptr = b->qcoeff; |
122 a = (ENTROPY_CONTEXT *)x->above_context + 8; | 123 a = (ENTROPY_CONTEXT *)xd->above_context + 8; |
123 l = (ENTROPY_CONTEXT *)x->left_context + 8; | 124 l = (ENTROPY_CONTEXT *)xd->left_context + 8; |
124 eob = x->eobs[24]; | 125 eob = xd->eobs[24]; |
125 VP8_COMBINEENTROPYCONTEXTS(pt, *a, *l); | 126 VP8_COMBINEENTROPYCONTEXTS(pt, *a, *l); |
126 | 127 |
127 if(!eob) | 128 if(!eob) |
128 { | 129 { |
129 /* c = band for this case */ | 130 /* c = band for this case */ |
130 t->Token = DCT_EOB_TOKEN; | 131 t->Token = DCT_EOB_TOKEN; |
131 t->context_tree = cpi->common.fc.coef_probs [1] [0] [pt]; | 132 t->context_tree = cpi->common.fc.coef_probs [1] [0] [pt]; |
132 t->skip_eob_node = 0; | 133 t->skip_eob_node = 0; |
133 | 134 |
134 ++cpi->coef_counts [1] [0] [pt] [DCT_EOB_TOKEN]; | 135 ++x->coef_counts [1] [0] [pt] [DCT_EOB_TOKEN]; |
135 t++; | 136 t++; |
136 *tp = t; | 137 *tp = t; |
137 *a = *l = 0; | 138 *a = *l = 0; |
138 return; | 139 return; |
139 } | 140 } |
140 | 141 |
141 v = qcoeff_ptr[0]; | 142 v = qcoeff_ptr[0]; |
142 t->Extra = vp8_dct_value_tokens_ptr[v].Extra; | 143 t->Extra = vp8_dct_value_tokens_ptr[v].Extra; |
143 token = vp8_dct_value_tokens_ptr[v].Token; | 144 token = vp8_dct_value_tokens_ptr[v].Token; |
144 t->Token = token; | 145 t->Token = token; |
145 | 146 |
146 t->context_tree = cpi->common.fc.coef_probs [1] [0] [pt]; | 147 t->context_tree = cpi->common.fc.coef_probs [1] [0] [pt]; |
147 t->skip_eob_node = 0; | 148 t->skip_eob_node = 0; |
148 ++cpi->coef_counts [1] [0] [pt] [token]; | 149 ++x->coef_counts [1] [0] [pt] [token]; |
149 pt = vp8_prev_token_class[token]; | 150 pt = vp8_prev_token_class[token]; |
150 t++; | 151 t++; |
151 c = 1; | 152 c = 1; |
152 | 153 |
153 for (; c < eob; c++) | 154 for (; c < eob; c++) |
154 { | 155 { |
155 rc = vp8_default_zig_zag1d[c]; | 156 rc = vp8_default_zig_zag1d[c]; |
156 band = vp8_coef_bands[c]; | 157 band = vp8_coef_bands[c]; |
157 v = qcoeff_ptr[rc]; | 158 v = qcoeff_ptr[rc]; |
158 | 159 |
159 t->Extra = vp8_dct_value_tokens_ptr[v].Extra; | 160 t->Extra = vp8_dct_value_tokens_ptr[v].Extra; |
160 token = vp8_dct_value_tokens_ptr[v].Token; | 161 token = vp8_dct_value_tokens_ptr[v].Token; |
161 | 162 |
162 t->Token = token; | 163 t->Token = token; |
163 t->context_tree = cpi->common.fc.coef_probs [1] [band] [pt]; | 164 t->context_tree = cpi->common.fc.coef_probs [1] [band] [pt]; |
164 | 165 |
165 t->skip_eob_node = ((pt == 0)); | 166 t->skip_eob_node = ((pt == 0)); |
166 | 167 |
167 ++cpi->coef_counts [1] [band] [pt] [token]; | 168 ++x->coef_counts [1] [band] [pt] [token]; |
168 | 169 |
169 pt = vp8_prev_token_class[token]; | 170 pt = vp8_prev_token_class[token]; |
170 t++; | 171 t++; |
171 } | 172 } |
172 if (c < 16) | 173 if (c < 16) |
173 { | 174 { |
174 band = vp8_coef_bands[c]; | 175 band = vp8_coef_bands[c]; |
175 t->Token = DCT_EOB_TOKEN; | 176 t->Token = DCT_EOB_TOKEN; |
176 t->context_tree = cpi->common.fc.coef_probs [1] [band] [pt]; | 177 t->context_tree = cpi->common.fc.coef_probs [1] [band] [pt]; |
177 | 178 |
178 t->skip_eob_node = 0; | 179 t->skip_eob_node = 0; |
179 | 180 |
180 ++cpi->coef_counts [1] [band] [pt] [DCT_EOB_TOKEN]; | 181 ++x->coef_counts [1] [band] [pt] [DCT_EOB_TOKEN]; |
181 | 182 |
182 t++; | 183 t++; |
183 } | 184 } |
184 | 185 |
185 *tp = t; | 186 *tp = t; |
186 *a = *l = 1; | 187 *a = *l = 1; |
187 | 188 |
188 } | 189 } |
189 | 190 |
190 static void tokenize1st_order_b | 191 static void tokenize1st_order_b |
191 ( | 192 ( |
192 MACROBLOCKD *x, | 193 MACROBLOCK *x, |
193 TOKENEXTRA **tp, | 194 TOKENEXTRA **tp, |
194 int type, /* which plane: 0=Y no DC, 1=Y2, 2=UV, 3=Y with DC */ | 195 int type, /* which plane: 0=Y no DC, 1=Y2, 2=UV, 3=Y with DC */ |
195 VP8_COMP *cpi | 196 VP8_COMP *cpi |
196 ) | 197 ) |
197 { | 198 { |
| 199 MACROBLOCKD *xd = &x->e_mbd; |
198 unsigned int block; | 200 unsigned int block; |
199 const BLOCKD *b; | 201 const BLOCKD *b; |
200 int pt; /* near block/prev token context index */ | 202 int pt; /* near block/prev token context index */ |
201 int c; | 203 int c; |
202 int token; | 204 int token; |
203 TOKENEXTRA *t = *tp;/* store tokens starting here */ | 205 TOKENEXTRA *t = *tp;/* store tokens starting here */ |
204 const short *qcoeff_ptr; | 206 const short *qcoeff_ptr; |
205 ENTROPY_CONTEXT * a; | 207 ENTROPY_CONTEXT * a; |
206 ENTROPY_CONTEXT * l; | 208 ENTROPY_CONTEXT * l; |
207 int band, rc, v; | 209 int band, rc, v; |
208 int tmp1, tmp2; | 210 int tmp1, tmp2; |
209 | 211 |
210 b = x->block; | 212 b = xd->block; |
211 /* Luma */ | 213 /* Luma */ |
212 for (block = 0; block < 16; block++, b++) | 214 for (block = 0; block < 16; block++, b++) |
213 { | 215 { |
214 tmp1 = vp8_block2above[block]; | 216 tmp1 = vp8_block2above[block]; |
215 tmp2 = vp8_block2left[block]; | 217 tmp2 = vp8_block2left[block]; |
216 qcoeff_ptr = b->qcoeff; | 218 qcoeff_ptr = b->qcoeff; |
217 a = (ENTROPY_CONTEXT *)x->above_context + tmp1; | 219 a = (ENTROPY_CONTEXT *)xd->above_context + tmp1; |
218 l = (ENTROPY_CONTEXT *)x->left_context + tmp2; | 220 l = (ENTROPY_CONTEXT *)xd->left_context + tmp2; |
219 | 221 |
220 VP8_COMBINEENTROPYCONTEXTS(pt, *a, *l); | 222 VP8_COMBINEENTROPYCONTEXTS(pt, *a, *l); |
221 | 223 |
222 c = type ? 0 : 1; | 224 c = type ? 0 : 1; |
223 | 225 |
224 if(c >= *b->eob) | 226 if(c >= *b->eob) |
225 { | 227 { |
226 /* c = band for this case */ | 228 /* c = band for this case */ |
227 t->Token = DCT_EOB_TOKEN; | 229 t->Token = DCT_EOB_TOKEN; |
228 t->context_tree = cpi->common.fc.coef_probs [type] [c] [pt]; | 230 t->context_tree = cpi->common.fc.coef_probs [type] [c] [pt]; |
229 t->skip_eob_node = 0; | 231 t->skip_eob_node = 0; |
230 | 232 |
231 ++cpi->coef_counts [type] [c] [pt] [DCT_EOB_TOKEN]; | 233 ++x->coef_counts [type] [c] [pt] [DCT_EOB_TOKEN]; |
232 t++; | 234 t++; |
233 *tp = t; | 235 *tp = t; |
234 *a = *l = 0; | 236 *a = *l = 0; |
235 continue; | 237 continue; |
236 } | 238 } |
237 | 239 |
238 v = qcoeff_ptr[c]; | 240 v = qcoeff_ptr[c]; |
239 | 241 |
240 t->Extra = vp8_dct_value_tokens_ptr[v].Extra; | 242 t->Extra = vp8_dct_value_tokens_ptr[v].Extra; |
241 token = vp8_dct_value_tokens_ptr[v].Token; | 243 token = vp8_dct_value_tokens_ptr[v].Token; |
242 t->Token = token; | 244 t->Token = token; |
243 | 245 |
244 t->context_tree = cpi->common.fc.coef_probs [type] [c] [pt]; | 246 t->context_tree = cpi->common.fc.coef_probs [type] [c] [pt]; |
245 t->skip_eob_node = 0; | 247 t->skip_eob_node = 0; |
246 ++cpi->coef_counts [type] [c] [pt] [token]; | 248 ++x->coef_counts [type] [c] [pt] [token]; |
247 pt = vp8_prev_token_class[token]; | 249 pt = vp8_prev_token_class[token]; |
248 t++; | 250 t++; |
249 c++; | 251 c++; |
250 | 252 |
251 for (; c < *b->eob; c++) | 253 for (; c < *b->eob; c++) |
252 { | 254 { |
253 rc = vp8_default_zig_zag1d[c]; | 255 rc = vp8_default_zig_zag1d[c]; |
254 band = vp8_coef_bands[c]; | 256 band = vp8_coef_bands[c]; |
255 v = qcoeff_ptr[rc]; | 257 v = qcoeff_ptr[rc]; |
256 | 258 |
257 t->Extra = vp8_dct_value_tokens_ptr[v].Extra; | 259 t->Extra = vp8_dct_value_tokens_ptr[v].Extra; |
258 token = vp8_dct_value_tokens_ptr[v].Token; | 260 token = vp8_dct_value_tokens_ptr[v].Token; |
259 | 261 |
260 t->Token = token; | 262 t->Token = token; |
261 t->context_tree = cpi->common.fc.coef_probs [type] [band] [pt]; | 263 t->context_tree = cpi->common.fc.coef_probs [type] [band] [pt]; |
262 | 264 |
263 t->skip_eob_node = (pt == 0); | 265 t->skip_eob_node = (pt == 0); |
264 ++cpi->coef_counts [type] [band] [pt] [token]; | 266 ++x->coef_counts [type] [band] [pt] [token]; |
265 | 267 |
266 pt = vp8_prev_token_class[token]; | 268 pt = vp8_prev_token_class[token]; |
267 t++; | 269 t++; |
268 } | 270 } |
269 if (c < 16) | 271 if (c < 16) |
270 { | 272 { |
271 band = vp8_coef_bands[c]; | 273 band = vp8_coef_bands[c]; |
272 t->Token = DCT_EOB_TOKEN; | 274 t->Token = DCT_EOB_TOKEN; |
273 t->context_tree = cpi->common.fc.coef_probs [type] [band] [pt]; | 275 t->context_tree = cpi->common.fc.coef_probs [type] [band] [pt]; |
274 | 276 |
275 t->skip_eob_node = 0; | 277 t->skip_eob_node = 0; |
276 ++cpi->coef_counts [type] [band] [pt] [DCT_EOB_TOKEN]; | 278 ++x->coef_counts [type] [band] [pt] [DCT_EOB_TOKEN]; |
277 | 279 |
278 t++; | 280 t++; |
279 } | 281 } |
280 *tp = t; | 282 *tp = t; |
281 *a = *l = 1; | 283 *a = *l = 1; |
282 } | 284 } |
283 | 285 |
284 /* Chroma */ | 286 /* Chroma */ |
285 for (block = 16; block < 24; block++, b++) | 287 for (block = 16; block < 24; block++, b++) |
286 { | 288 { |
287 tmp1 = vp8_block2above[block]; | 289 tmp1 = vp8_block2above[block]; |
288 tmp2 = vp8_block2left[block]; | 290 tmp2 = vp8_block2left[block]; |
289 qcoeff_ptr = b->qcoeff; | 291 qcoeff_ptr = b->qcoeff; |
290 a = (ENTROPY_CONTEXT *)x->above_context + tmp1; | 292 a = (ENTROPY_CONTEXT *)xd->above_context + tmp1; |
291 l = (ENTROPY_CONTEXT *)x->left_context + tmp2; | 293 l = (ENTROPY_CONTEXT *)xd->left_context + tmp2; |
292 | 294 |
293 VP8_COMBINEENTROPYCONTEXTS(pt, *a, *l); | 295 VP8_COMBINEENTROPYCONTEXTS(pt, *a, *l); |
294 | 296 |
295 if(!(*b->eob)) | 297 if(!(*b->eob)) |
296 { | 298 { |
297 /* c = band for this case */ | 299 /* c = band for this case */ |
298 t->Token = DCT_EOB_TOKEN; | 300 t->Token = DCT_EOB_TOKEN; |
299 t->context_tree = cpi->common.fc.coef_probs [2] [0] [pt]; | 301 t->context_tree = cpi->common.fc.coef_probs [2] [0] [pt]; |
300 t->skip_eob_node = 0; | 302 t->skip_eob_node = 0; |
301 | 303 |
302 ++cpi->coef_counts [2] [0] [pt] [DCT_EOB_TOKEN]; | 304 ++x->coef_counts [2] [0] [pt] [DCT_EOB_TOKEN]; |
303 t++; | 305 t++; |
304 *tp = t; | 306 *tp = t; |
305 *a = *l = 0; | 307 *a = *l = 0; |
306 continue; | 308 continue; |
307 } | 309 } |
308 | 310 |
309 v = qcoeff_ptr[0]; | 311 v = qcoeff_ptr[0]; |
310 | 312 |
311 t->Extra = vp8_dct_value_tokens_ptr[v].Extra; | 313 t->Extra = vp8_dct_value_tokens_ptr[v].Extra; |
312 token = vp8_dct_value_tokens_ptr[v].Token; | 314 token = vp8_dct_value_tokens_ptr[v].Token; |
313 t->Token = token; | 315 t->Token = token; |
314 | 316 |
315 t->context_tree = cpi->common.fc.coef_probs [2] [0] [pt]; | 317 t->context_tree = cpi->common.fc.coef_probs [2] [0] [pt]; |
316 t->skip_eob_node = 0; | 318 t->skip_eob_node = 0; |
317 ++cpi->coef_counts [2] [0] [pt] [token]; | 319 ++x->coef_counts [2] [0] [pt] [token]; |
318 pt = vp8_prev_token_class[token]; | 320 pt = vp8_prev_token_class[token]; |
319 t++; | 321 t++; |
320 c = 1; | 322 c = 1; |
321 | 323 |
322 for (; c < *b->eob; c++) | 324 for (; c < *b->eob; c++) |
323 { | 325 { |
324 rc = vp8_default_zig_zag1d[c]; | 326 rc = vp8_default_zig_zag1d[c]; |
325 band = vp8_coef_bands[c]; | 327 band = vp8_coef_bands[c]; |
326 v = qcoeff_ptr[rc]; | 328 v = qcoeff_ptr[rc]; |
327 | 329 |
328 t->Extra = vp8_dct_value_tokens_ptr[v].Extra; | 330 t->Extra = vp8_dct_value_tokens_ptr[v].Extra; |
329 token = vp8_dct_value_tokens_ptr[v].Token; | 331 token = vp8_dct_value_tokens_ptr[v].Token; |
330 | 332 |
331 t->Token = token; | 333 t->Token = token; |
332 t->context_tree = cpi->common.fc.coef_probs [2] [band] [pt]; | 334 t->context_tree = cpi->common.fc.coef_probs [2] [band] [pt]; |
333 | 335 |
334 t->skip_eob_node = (pt == 0); | 336 t->skip_eob_node = (pt == 0); |
335 | 337 |
336 ++cpi->coef_counts [2] [band] [pt] [token]; | 338 ++x->coef_counts [2] [band] [pt] [token]; |
337 | 339 |
338 pt = vp8_prev_token_class[token]; | 340 pt = vp8_prev_token_class[token]; |
339 t++; | 341 t++; |
340 } | 342 } |
341 if (c < 16) | 343 if (c < 16) |
342 { | 344 { |
343 band = vp8_coef_bands[c]; | 345 band = vp8_coef_bands[c]; |
344 t->Token = DCT_EOB_TOKEN; | 346 t->Token = DCT_EOB_TOKEN; |
345 t->context_tree = cpi->common.fc.coef_probs [2] [band] [pt]; | 347 t->context_tree = cpi->common.fc.coef_probs [2] [band] [pt]; |
346 | 348 |
347 t->skip_eob_node = 0; | 349 t->skip_eob_node = 0; |
348 | 350 |
349 ++cpi->coef_counts [2] [band] [pt] [DCT_EOB_TOKEN]; | 351 ++x->coef_counts [2] [band] [pt] [DCT_EOB_TOKEN]; |
350 | 352 |
351 t++; | 353 t++; |
352 } | 354 } |
353 *tp = t; | 355 *tp = t; |
354 *a = *l = 1; | 356 *a = *l = 1; |
355 } | 357 } |
356 } | 358 } |
357 | 359 |
358 | 360 |
359 static int mb_is_skippable(MACROBLOCKD *x, int has_y2_block) | 361 static int mb_is_skippable(MACROBLOCKD *x, int has_y2_block) |
360 { | 362 { |
361 int skip = 1; | 363 int skip = 1; |
362 int i = 0; | 364 int i = 0; |
363 | 365 |
364 if (has_y2_block) | 366 if (has_y2_block) |
365 { | 367 { |
366 for (i = 0; i < 16; i++) | 368 for (i = 0; i < 16; i++) |
367 skip &= (x->eobs[i] < 2); | 369 skip &= (x->eobs[i] < 2); |
368 } | 370 } |
369 | 371 |
370 for (; i < 24 + has_y2_block; i++) | 372 for (; i < 24 + has_y2_block; i++) |
371 skip &= (!x->eobs[i]); | 373 skip &= (!x->eobs[i]); |
372 | 374 |
373 return skip; | 375 return skip; |
374 } | 376 } |
375 | 377 |
376 | 378 |
377 void vp8_tokenize_mb(VP8_COMP *cpi, MACROBLOCKD *x, TOKENEXTRA **t) | 379 void vp8_tokenize_mb(VP8_COMP *cpi, MACROBLOCK *x, TOKENEXTRA **t) |
378 { | 380 { |
| 381 MACROBLOCKD *xd = &x->e_mbd; |
379 int plane_type; | 382 int plane_type; |
380 int has_y2_block; | 383 int has_y2_block; |
381 | 384 |
382 has_y2_block = (x->mode_info_context->mbmi.mode != B_PRED | 385 has_y2_block = (xd->mode_info_context->mbmi.mode != B_PRED |
383 && x->mode_info_context->mbmi.mode != SPLITMV); | 386 && xd->mode_info_context->mbmi.mode != SPLITMV); |
384 | 387 |
385 x->mode_info_context->mbmi.mb_skip_coeff = mb_is_skippable(x, has_y2_block); | 388 xd->mode_info_context->mbmi.mb_skip_coeff = |
386 if (x->mode_info_context->mbmi.mb_skip_coeff) | 389 mb_is_skippable(xd, has_y2_block); |
| 390 if (xd->mode_info_context->mbmi.mb_skip_coeff) |
387 { | 391 { |
388 if (!cpi->common.mb_no_coeff_skip) | 392 if (!cpi->common.mb_no_coeff_skip) |
389 { | 393 { |
390 vp8_stuff_mb(cpi, x, t); | 394 vp8_stuff_mb(cpi, x, t); |
391 } | 395 } |
392 else | 396 else |
393 { | 397 { |
394 vp8_fix_contexts(x); | 398 vp8_fix_contexts(xd); |
395 cpi->skip_true_count++; | 399 x->skip_true_count++; |
396 } | 400 } |
397 | 401 |
398 return; | 402 return; |
399 } | 403 } |
400 | 404 |
401 plane_type = 3; | 405 plane_type = 3; |
402 if(has_y2_block) | 406 if(has_y2_block) |
403 { | 407 { |
404 tokenize2nd_order_b(x, t, cpi); | 408 tokenize2nd_order_b(x, t, cpi); |
405 plane_type = 0; | 409 plane_type = 0; |
(...skipping 75 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
481 fclose(f); | 485 fclose(f); |
482 } | 486 } |
483 #endif | 487 #endif |
484 | 488 |
485 | 489 |
486 static void stuff2nd_order_b | 490 static void stuff2nd_order_b |
487 ( | 491 ( |
488 TOKENEXTRA **tp, | 492 TOKENEXTRA **tp, |
489 ENTROPY_CONTEXT *a, | 493 ENTROPY_CONTEXT *a, |
490 ENTROPY_CONTEXT *l, | 494 ENTROPY_CONTEXT *l, |
491 VP8_COMP *cpi | 495 VP8_COMP *cpi, |
| 496 MACROBLOCK *x |
492 ) | 497 ) |
493 { | 498 { |
494 int pt; /* near block/prev token context index */ | 499 int pt; /* near block/prev token context index */ |
495 TOKENEXTRA *t = *tp; /* store tokens starting here */ | 500 TOKENEXTRA *t = *tp; /* store tokens starting here */ |
496 VP8_COMBINEENTROPYCONTEXTS(pt, *a, *l); | 501 VP8_COMBINEENTROPYCONTEXTS(pt, *a, *l); |
497 | 502 |
498 t->Token = DCT_EOB_TOKEN; | 503 t->Token = DCT_EOB_TOKEN; |
499 t->context_tree = cpi->common.fc.coef_probs [1] [0] [pt]; | 504 t->context_tree = cpi->common.fc.coef_probs [1] [0] [pt]; |
500 t->skip_eob_node = 0; | 505 t->skip_eob_node = 0; |
501 ++cpi->coef_counts [1] [0] [pt] [DCT_EOB_TOKEN]; | 506 ++x->coef_counts [1] [0] [pt] [DCT_EOB_TOKEN]; |
502 ++t; | 507 ++t; |
503 | 508 |
504 *tp = t; | 509 *tp = t; |
505 pt = 0; | 510 pt = 0; |
506 *a = *l = pt; | 511 *a = *l = pt; |
507 | |
508 } | 512 } |
509 | 513 |
510 static void stuff1st_order_b | 514 static void stuff1st_order_b |
511 ( | 515 ( |
512 TOKENEXTRA **tp, | 516 TOKENEXTRA **tp, |
513 ENTROPY_CONTEXT *a, | 517 ENTROPY_CONTEXT *a, |
514 ENTROPY_CONTEXT *l, | 518 ENTROPY_CONTEXT *l, |
515 int type, | 519 int type, |
516 VP8_COMP *cpi | 520 VP8_COMP *cpi, |
| 521 MACROBLOCK *x |
517 ) | 522 ) |
518 { | 523 { |
519 int pt; /* near block/prev token context index */ | 524 int pt; /* near block/prev token context index */ |
520 int band; | 525 int band; |
521 TOKENEXTRA *t = *tp; /* store tokens starting here */ | 526 TOKENEXTRA *t = *tp; /* store tokens starting here */ |
522 VP8_COMBINEENTROPYCONTEXTS(pt, *a, *l); | 527 VP8_COMBINEENTROPYCONTEXTS(pt, *a, *l); |
523 band = type ? 0 : 1; | 528 band = type ? 0 : 1; |
524 t->Token = DCT_EOB_TOKEN; | 529 t->Token = DCT_EOB_TOKEN; |
525 t->context_tree = cpi->common.fc.coef_probs [type] [band] [pt]; | 530 t->context_tree = cpi->common.fc.coef_probs [type] [band] [pt]; |
526 t->skip_eob_node = 0; | 531 t->skip_eob_node = 0; |
527 ++cpi->coef_counts [type] [band] [pt] [DCT_EOB_TOKEN]; | 532 ++x->coef_counts [type] [band] [pt] [DCT_EOB_TOKEN]; |
528 ++t; | 533 ++t; |
529 *tp = t; | 534 *tp = t; |
530 pt = 0; /* 0 <-> all coeff data is zero */ | 535 pt = 0; /* 0 <-> all coeff data is zero */ |
531 *a = *l = pt; | 536 *a = *l = pt; |
| 537 } |
532 | 538 |
533 } | |
534 static | 539 static |
535 void stuff1st_order_buv | 540 void stuff1st_order_buv |
536 ( | 541 ( |
537 TOKENEXTRA **tp, | 542 TOKENEXTRA **tp, |
538 ENTROPY_CONTEXT *a, | 543 ENTROPY_CONTEXT *a, |
539 ENTROPY_CONTEXT *l, | 544 ENTROPY_CONTEXT *l, |
540 VP8_COMP *cpi | 545 VP8_COMP *cpi, |
| 546 MACROBLOCK *x |
541 ) | 547 ) |
542 { | 548 { |
543 int pt; /* near block/prev token context index */ | 549 int pt; /* near block/prev token context index */ |
544 TOKENEXTRA *t = *tp; /* store tokens starting here */ | 550 TOKENEXTRA *t = *tp; /* store tokens starting here */ |
545 VP8_COMBINEENTROPYCONTEXTS(pt, *a, *l); | 551 VP8_COMBINEENTROPYCONTEXTS(pt, *a, *l); |
546 | 552 |
547 t->Token = DCT_EOB_TOKEN; | 553 t->Token = DCT_EOB_TOKEN; |
548 t->context_tree = cpi->common.fc.coef_probs [2] [0] [pt]; | 554 t->context_tree = cpi->common.fc.coef_probs [2] [0] [pt]; |
549 t->skip_eob_node = 0; | 555 t->skip_eob_node = 0; |
550 ++cpi->coef_counts[2] [0] [pt] [DCT_EOB_TOKEN]; | 556 ++x->coef_counts[2] [0] [pt] [DCT_EOB_TOKEN]; |
551 ++t; | 557 ++t; |
552 *tp = t; | 558 *tp = t; |
553 pt = 0; /* 0 <-> all coeff data is zero */ | 559 pt = 0; /* 0 <-> all coeff data is zero */ |
554 *a = *l = pt; | 560 *a = *l = pt; |
555 | |
556 } | 561 } |
557 | 562 |
558 void vp8_stuff_mb(VP8_COMP *cpi, MACROBLOCKD *x, TOKENEXTRA **t) | 563 void vp8_stuff_mb(VP8_COMP *cpi, MACROBLOCK *x, TOKENEXTRA **t) |
559 { | 564 { |
560 ENTROPY_CONTEXT * A = (ENTROPY_CONTEXT *)x->above_context; | 565 MACROBLOCKD *xd = &x->e_mbd; |
561 ENTROPY_CONTEXT * L = (ENTROPY_CONTEXT *)x->left_context; | 566 ENTROPY_CONTEXT * A = (ENTROPY_CONTEXT *)xd->above_context; |
| 567 ENTROPY_CONTEXT * L = (ENTROPY_CONTEXT *)xd->left_context; |
562 int plane_type; | 568 int plane_type; |
563 int b; | 569 int b; |
564 plane_type = 3; | 570 plane_type = 3; |
565 if((x->mode_info_context->mbmi.mode != B_PRED | 571 if((xd->mode_info_context->mbmi.mode != B_PRED |
566 && x->mode_info_context->mbmi.mode != SPLITMV)) | 572 && xd->mode_info_context->mbmi.mode != SPLITMV)) |
567 { | 573 { |
568 stuff2nd_order_b(t, | 574 stuff2nd_order_b(t, |
569 A + vp8_block2above[24], L + vp8_block2left[24], cpi); | 575 A + vp8_block2above[24], L + vp8_block2left[24], cpi, x); |
570 plane_type = 0; | 576 plane_type = 0; |
571 } | 577 } |
572 | 578 |
573 for (b = 0; b < 16; b++) | 579 for (b = 0; b < 16; b++) |
574 stuff1st_order_b(t, | 580 stuff1st_order_b(t, |
575 A + vp8_block2above[b], | 581 A + vp8_block2above[b], |
576 L + vp8_block2left[b], plane_type, cpi); | 582 L + vp8_block2left[b], plane_type, cpi, x); |
577 | 583 |
578 for (b = 16; b < 24; b++) | 584 for (b = 16; b < 24; b++) |
579 stuff1st_order_buv(t, | 585 stuff1st_order_buv(t, |
580 A + vp8_block2above[b], | 586 A + vp8_block2above[b], |
581 L + vp8_block2left[b], cpi); | 587 L + vp8_block2left[b], cpi, x); |
582 | 588 |
583 } | 589 } |
584 void vp8_fix_contexts(MACROBLOCKD *x) | 590 void vp8_fix_contexts(MACROBLOCKD *x) |
585 { | 591 { |
586 /* Clear entropy contexts for Y2 blocks */ | 592 /* Clear entropy contexts for Y2 blocks */ |
587 if (x->mode_info_context->mbmi.mode != B_PRED && x->mode_info_context->mbmi.
mode != SPLITMV) | 593 if (x->mode_info_context->mbmi.mode != B_PRED && x->mode_info_context->mbmi.
mode != SPLITMV) |
588 { | 594 { |
589 vpx_memset(x->above_context, 0, sizeof(ENTROPY_CONTEXT_PLANES)); | 595 vpx_memset(x->above_context, 0, sizeof(ENTROPY_CONTEXT_PLANES)); |
590 vpx_memset(x->left_context, 0, sizeof(ENTROPY_CONTEXT_PLANES)); | 596 vpx_memset(x->left_context, 0, sizeof(ENTROPY_CONTEXT_PLANES)); |
591 } | 597 } |
592 else | 598 else |
593 { | 599 { |
594 vpx_memset(x->above_context, 0, sizeof(ENTROPY_CONTEXT_PLANES)-1); | 600 vpx_memset(x->above_context, 0, sizeof(ENTROPY_CONTEXT_PLANES)-1); |
595 vpx_memset(x->left_context, 0, sizeof(ENTROPY_CONTEXT_PLANES)-1); | 601 vpx_memset(x->left_context, 0, sizeof(ENTROPY_CONTEXT_PLANES)-1); |
596 } | 602 } |
597 | 603 |
598 } | 604 } |
OLD | NEW |