?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Merge "Pack invisible frames without lengths" into experimental
[aom.git] / vp9 / decoder / decodframe.c
blobe7d5667f8d17026d531f8f8b9fde94f082a0c907
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 "onyxd_int.h"
13 #include "vp9/common/header.h"
14 #include "vp9/common/reconintra.h"
15 #include "vp9/common/reconintra4x4.h"
16 #include "vp9/common/reconinter.h"
17 #include "vp9/decoder/decodframe.h"
18 #include "detokenize.h"
19 #include "vp9/common/invtrans.h"
20 #include "vp9/common/alloccommon.h"
21 #include "vp9/common/entropymode.h"
22 #include "vp9/common/quant_common.h"
23 #include "vpx_scale/vpxscale.h"
24 #include "vp9/common/setupintrarecon.h"
25
26 #include "decodemv.h"
27 #include "vp9/common/extend.h"
28 #include "vp9/common/modecont.h"
29 #include "vpx_mem/vpx_mem.h"
30 #include "vp9/common/idct.h"
31 #include "dboolhuff.h"
32
33 #include "vp9/common/seg_common.h"
34 #include "vp9/common/entropy.h"
35 #include "vp9_rtcd.h"
36
37 #include <assert.h>
38 #include <stdio.h>
39
40
41 #define COEFCOUNT_TESTING
42
43 static int merge_index(int v, int n, int modulus) {
44 int max1 = (n - 1 - modulus / 2) / modulus + 1;
45 if (v < max1) v = v * modulus + modulus / 2;
46 else {
47 int w;
48 v -= max1;
49 w = v;
50 v += (v + modulus - modulus / 2) / modulus;
51 while (v % modulus == modulus / 2 ||
52 w != v - (v + modulus - modulus / 2) / modulus) v++;
53 }
54 return v;
55 }
56
57 static int inv_remap_prob(int v, int m) {
58 const int n = 256;
59 const int modulus = MODULUS_PARAM;
60 int i;
61 v = merge_index(v, n - 1, modulus);
62 if ((m << 1) <= n) {
63 i = vp9_inv_recenter_nonneg(v + 1, m);
64 } else {
65 i = n - 1 - vp9_inv_recenter_nonneg(v + 1, n - 1 - m);
66 }
67 return i;
68 }
69
70 static vp9_prob read_prob_diff_update(vp9_reader *const bc, int oldp) {
71 int delp = vp9_decode_term_subexp(bc, SUBEXP_PARAM, 255);
72 return (vp9_prob)inv_remap_prob(delp, oldp);
73 }
74
75 void vp9_init_de_quantizer(VP9D_COMP *pbi) {
76 int i;
77 int Q;
78 VP9_COMMON *const pc = &pbi->common;
79
80 for (Q = 0; Q < QINDEX_RANGE; Q++) {
81 pc->Y1dequant[Q][0] = (short)vp9_dc_quant(Q, pc->y1dc_delta_q);
82 pc->Y2dequant[Q][0] = (short)vp9_dc2quant(Q, pc->y2dc_delta_q);
83 pc->UVdequant[Q][0] = (short)vp9_dc_uv_quant(Q, pc->uvdc_delta_q);
84
85 /* all the ac values =; */
86 for (i = 1; i < 16; i++) {
87 int rc = vp9_default_zig_zag1d[i];
88
89 pc->Y1dequant[Q][rc] = (short)vp9_ac_yquant(Q);
90 pc->Y2dequant[Q][rc] = (short)vp9_ac2quant(Q, pc->y2ac_delta_q);
91 pc->UVdequant[Q][rc] = (short)vp9_ac_uv_quant(Q, pc->uvac_delta_q);
92 }
93 }
94 }
95
96 static void mb_init_dequantizer(VP9D_COMP *pbi, MACROBLOCKD *xd) {
97 int i;
98 int QIndex;
99 VP9_COMMON *const pc = &pbi->common;
100 int segment_id = xd->mode_info_context->mbmi.segment_id;
101
102 // Set the Q baseline allowing for any segment level adjustment
103 if (vp9_segfeature_active(xd, segment_id, SEG_LVL_ALT_Q)) {
104 /* Abs Value */
105 if (xd->mb_segment_abs_delta == SEGMENT_ABSDATA)
106 QIndex = vp9_get_segdata(xd, segment_id, SEG_LVL_ALT_Q);
107
108 /* Delta Value */
109 else {
110 QIndex = pc->base_qindex +
111 vp9_get_segdata(xd, segment_id, SEG_LVL_ALT_Q);
112 QIndex = (QIndex >= 0) ? ((QIndex <= MAXQ) ? QIndex : MAXQ) : 0; /* Clamp to valid range */
113 }
114 } else
115 QIndex = pc->base_qindex;
116 xd->q_index = QIndex;
117
118 /* Set up the block level dequant pointers */
119 for (i = 0; i < 16; i++) {
120 xd->block[i].dequant = pc->Y1dequant[QIndex];
121 }
122
123 #if CONFIG_LOSSLESS
124 if (!QIndex) {
125 pbi->common.rtcd.idct.idct1 = vp9_short_inv_walsh4x4_1_x8_c;
126 pbi->common.rtcd.idct.idct16 = vp9_short_inv_walsh4x4_x8_c;
127 pbi->common.rtcd.idct.idct1_scalar_add = vp9_dc_only_inv_walsh_add_c;
128 pbi->common.rtcd.idct.iwalsh1 = vp9_short_inv_walsh4x4_1_lossless_c;
129 pbi->common.rtcd.idct.iwalsh16 = vp9_short_inv_walsh4x4_lossless_c;
130 pbi->idct_add = vp9_dequant_idct_add_lossless_c;
131 pbi->dc_idct_add = vp9_dequant_dc_idct_add_lossless_c;
132 pbi->dc_idct_add_y_block = vp9_dequant_dc_idct_add_y_block_lossless_c;
133 pbi->idct_add_y_block = vp9_dequant_idct_add_y_block_lossless_c;
134 pbi->idct_add_uv_block = vp9_dequant_idct_add_uv_block_lossless_c;
135 } else {
136 pbi->common.rtcd.idct.idct1 = vp9_short_idct4x4llm_1_c;
137 pbi->common.rtcd.idct.idct16 = vp9_short_idct4x4llm_c;
138 pbi->common.rtcd.idct.idct1_scalar_add = vp9_dc_only_idct_add_c;
139 pbi->common.rtcd.idct.iwalsh1 = vp9_short_inv_walsh4x4_1_c;
140 pbi->common.rtcd.idct.iwalsh16 = vp9_short_inv_walsh4x4_c;
141 pbi->idct_add = vp9_dequant_idct_add;
142 pbi->dc_idct_add = vp9_dequant_dc_idct_add;
143 pbi->dc_idct_add_y_block = vp9_dequant_dc_idct_add_y_block;
144 pbi->idct_add_y_block = vp9_dequant_idct_add_y_block;
145 pbi->idct_add_uv_block = vp9_dequant_idct_add_uv_block;
146 }
147 #else
148 pbi->idct_add = vp9_dequant_idct_add;
149 pbi->dc_idct_add = vp9_dequant_dc_idct_add;
150 pbi->dc_idct_add_y_block = vp9_dequant_dc_idct_add_y_block;
151 pbi->idct_add_y_block = vp9_dequant_idct_add_y_block;
152 pbi->idct_add_uv_block = vp9_dequant_idct_add_uv_block;
153 #endif
154
155 for (i = 16; i < 24; i++) {
156 xd->block[i].dequant = pc->UVdequant[QIndex];
157 }
158
159 xd->block[24].dequant = pc->Y2dequant[QIndex];
160
161 }
162
163 #if CONFIG_RUNTIME_CPU_DETECT
164 #define RTCD_VTABLE(x) (&(pbi)->common.rtcd.x)
165 #else
166 #define RTCD_VTABLE(x) NULL
167 #endif
168
169 /* skip_recon_mb() is Modified: Instead of writing the result to predictor buffer and then copying it
170 * to dst buffer, we can write the result directly to dst buffer. This eliminates unnecessary copy.
171 */
172 static void skip_recon_mb(VP9D_COMP *pbi, MACROBLOCKD *xd) {
173 if (xd->mode_info_context->mbmi.ref_frame == INTRA_FRAME) {
174 #if CONFIG_SUPERBLOCKS
175 if (xd->mode_info_context->mbmi.encoded_as_sb) {
176 vp9_build_intra_predictors_sbuv_s(xd);
177 vp9_build_intra_predictors_sby_s(xd);
178 } else {
179 #endif
180 vp9_build_intra_predictors_mbuv_s(xd);
181 vp9_build_intra_predictors_mby_s(xd);
182 #if CONFIG_SUPERBLOCKS
183 }
184 #endif
185 } else {
186 #if CONFIG_SUPERBLOCKS
187 if (xd->mode_info_context->mbmi.encoded_as_sb) {
188 vp9_build_inter32x32_predictors_sb(xd,
189 xd->dst.y_buffer,
190 xd->dst.u_buffer,
191 xd->dst.v_buffer,
192 xd->dst.y_stride,
193 xd->dst.uv_stride);
194 } else {
195 #endif
196 vp9_build_1st_inter16x16_predictors_mb(xd,
197 xd->dst.y_buffer,
198 xd->dst.u_buffer,
199 xd->dst.v_buffer,
200 xd->dst.y_stride,
201 xd->dst.uv_stride);
202
203 if (xd->mode_info_context->mbmi.second_ref_frame > 0) {
204 vp9_build_2nd_inter16x16_predictors_mb(xd,
205 xd->dst.y_buffer,
206 xd->dst.u_buffer,
207 xd->dst.v_buffer,
208 xd->dst.y_stride,
209 xd->dst.uv_stride);
210 }
211 #if CONFIG_COMP_INTERINTRA_PRED
212 else if (xd->mode_info_context->mbmi.second_ref_frame == INTRA_FRAME) {
213 vp9_build_interintra_16x16_predictors_mb(xd,
214 xd->dst.y_buffer,
215 xd->dst.u_buffer,
216 xd->dst.v_buffer,
217 xd->dst.y_stride,
218 xd->dst.uv_stride);
219 }
220 #endif
221 #if CONFIG_SUPERBLOCKS
222 }
223 #endif
224 }
225 }
226
227 #if CONFIG_SUPERBLOCKS
228 static void decode_superblock(VP9D_COMP *pbi, MACROBLOCKD *xd,
229 int mb_row, unsigned int mb_col,
230 BOOL_DECODER* const bc) {
231 int i, n, eobtotal;
232 TX_SIZE tx_size = xd->mode_info_context->mbmi.txfm_size;
233 VP9_COMMON *const pc = &pbi->common;
234 MODE_INFO *orig_mi = xd->mode_info_context;
235
236 assert(xd->mode_info_context->mbmi.encoded_as_sb);
237
238 // re-initialize macroblock dequantizer before detokenization
239 if (xd->segmentation_enabled)
240 mb_init_dequantizer(pbi, xd);
241
242 if (pbi->common.frame_type != KEY_FRAME)
243 vp9_setup_interp_filters(xd, xd->mode_info_context->mbmi.interp_filter, pc);
244
245 if (xd->mode_info_context->mbmi.mb_skip_coeff) {
246 vp9_reset_mb_tokens_context(xd);
247 if (mb_col < pc->mb_cols - 1)
248 xd->above_context++;
249 if (mb_row < pc->mb_rows - 1)
250 xd->left_context++;
251 vp9_reset_mb_tokens_context(xd);
252 if (mb_col < pc->mb_cols - 1)
253 xd->above_context--;
254 if (mb_row < pc->mb_rows - 1)
255 xd->left_context--;
256
257 /* Special case: Force the loopfilter to skip when eobtotal and
258 * mb_skip_coeff are zero.
259 */
260 skip_recon_mb(pbi, xd);
261 return;
262 }
263
264 /* do prediction */
265 if (xd->mode_info_context->mbmi.ref_frame == INTRA_FRAME) {
266 vp9_build_intra_predictors_sby_s(xd);
267 vp9_build_intra_predictors_sbuv_s(xd);
268 } else {
269 vp9_build_inter32x32_predictors_sb(xd, xd->dst.y_buffer,
270 xd->dst.u_buffer, xd->dst.v_buffer,
271 xd->dst.y_stride, xd->dst.uv_stride);
272 }
273
274 /* dequantization and idct */
275 for (n = 0; n < 4; n++) {
276 BLOCKD *b = &xd->block[24];
277 int x_idx = n & 1, y_idx = n >> 1;
278
279 if (mb_col + x_idx >= pc->mb_cols || mb_row + y_idx >= pc->mb_rows)
280 continue;
281
282 xd->above_context = pc->above_context + mb_col + x_idx;
283 xd->left_context = pc->left_context + y_idx;
284 xd->mode_info_context = orig_mi + x_idx + y_idx * pc->mode_info_stride;
285 for (i = 0; i < 25; i++) {
286 xd->block[i].eob = 0;
287 xd->eobs[i] = 0;
288 }
289
290 if (tx_size == TX_16X16) {
291 eobtotal = vp9_decode_mb_tokens_16x16(pbi, xd, bc);
292 } else if (tx_size == TX_8X8) {
293 eobtotal = vp9_decode_mb_tokens_8x8(pbi, xd, bc);
294 } else {
295 eobtotal = vp9_decode_mb_tokens_4x4(pbi, xd, bc);
296 }
297 if (eobtotal == 0) { // skip loopfilter
298 xd->mode_info_context->mbmi.mb_skip_coeff = 1;
299 continue;
300 }
301
302 if (tx_size == TX_16X16) {
303 vp9_dequant_idct_add_16x16(xd->qcoeff, xd->block[0].dequant,
304 xd->dst.y_buffer + y_idx * 16 * xd->dst.y_stride + x_idx * 16,
305 xd->dst.y_buffer + y_idx * 16 * xd->dst.y_stride + x_idx * 16,
306 xd->dst.y_stride, xd->dst.y_stride, xd->eobs[0]);
307 vp9_dequant_idct_add_uv_block_8x8_inplace_c(xd->qcoeff + 16 * 16,
308 xd->block[16].dequant,
309 xd->dst.u_buffer + y_idx * 8 * xd->dst.uv_stride + x_idx * 8,
310 xd->dst.v_buffer + y_idx * 8 * xd->dst.uv_stride + x_idx * 8,
311 xd->dst.uv_stride, xd->eobs + 16, xd);
312 } else if (tx_size == TX_8X8) {
313 vp9_dequantize_b_2x2(b);
314 IDCT_INVOKE(RTCD_VTABLE(idct), ihaar2)(&b->dqcoeff[0], b->diff, 8);
315 ((int *)b->qcoeff)[0] = 0; // 2nd order block are set to 0 after idct
316 ((int *)b->qcoeff)[1] = 0;
317 ((int *)b->qcoeff)[2] = 0;
318 ((int *)b->qcoeff)[3] = 0;
319 ((int *)b->qcoeff)[4] = 0;
320 ((int *)b->qcoeff)[5] = 0;
321 ((int *)b->qcoeff)[6] = 0;
322 ((int *)b->qcoeff)[7] = 0;
323 vp9_dequant_dc_idct_add_y_block_8x8_inplace_c(xd->qcoeff,
324 xd->block[0].dequant,
325 xd->dst.y_buffer + y_idx * 16 * xd->dst.y_stride + x_idx * 16,
326 xd->dst.y_stride, xd->eobs, xd->block[24].diff, xd);
327 vp9_dequant_idct_add_uv_block_8x8_inplace_c(xd->qcoeff + 16 * 16,
328 xd->block[16].dequant,
329 xd->dst.u_buffer + y_idx * 8 * xd->dst.uv_stride + x_idx * 8,
330 xd->dst.v_buffer + y_idx * 8 * xd->dst.uv_stride + x_idx * 8,
331 xd->dst.uv_stride, xd->eobs + 16, xd);
332 } else {
333 vp9_dequantize_b(b);
334 if (xd->eobs[24] > 1) {
335 IDCT_INVOKE(RTCD_VTABLE(idct), iwalsh16)(&b->dqcoeff[0], b->diff);
336 ((int *)b->qcoeff)[0] = 0;
337 ((int *)b->qcoeff)[1] = 0;
338 ((int *)b->qcoeff)[2] = 0;
339 ((int *)b->qcoeff)[3] = 0;
340 ((int *)b->qcoeff)[4] = 0;
341 ((int *)b->qcoeff)[5] = 0;
342 ((int *)b->qcoeff)[6] = 0;
343 ((int *)b->qcoeff)[7] = 0;
344 } else {
345 IDCT_INVOKE(RTCD_VTABLE(idct), iwalsh1)(&b->dqcoeff[0], b->diff);
346 ((int *)b->qcoeff)[0] = 0;
347 }
348
349 vp9_dequant_dc_idct_add_y_block_4x4_inplace_c(xd->qcoeff,
350 xd->block[0].dequant,
351 xd->dst.y_buffer + y_idx * 16 * xd->dst.y_stride + x_idx * 16,
352 xd->dst.y_stride, xd->eobs, xd->block[24].diff, xd);
353 vp9_dequant_idct_add_uv_block_4x4_inplace_c(xd->qcoeff + 16 * 16,
354 xd->block[16].dequant,
355 xd->dst.u_buffer + y_idx * 8 * xd->dst.uv_stride + x_idx * 8,
356 xd->dst.v_buffer + y_idx * 8 * xd->dst.uv_stride + x_idx * 8,
357 xd->dst.uv_stride, xd->eobs + 16, xd);
358 }
359 }
360
361 xd->above_context = pc->above_context + mb_col;
362 xd->left_context = pc->left_context;
363 xd->mode_info_context = orig_mi;
364 }
365 #endif
366
367 static void decode_macroblock(VP9D_COMP *pbi, MACROBLOCKD *xd,
368 int mb_row, unsigned int mb_col,
369 BOOL_DECODER* const bc) {
370 int eobtotal = 0;
371 MB_PREDICTION_MODE mode;
372 int i;
373 int tx_size;
374 TX_TYPE tx_type;
375
376 #if CONFIG_SUPERBLOCKS
377 assert(!xd->mode_info_context->mbmi.encoded_as_sb);
378 #endif
379
380 // re-initialize macroblock dequantizer before detokenization
381 if (xd->segmentation_enabled)
382 mb_init_dequantizer(pbi, xd);
383
384 tx_size = xd->mode_info_context->mbmi.txfm_size;
385 mode = xd->mode_info_context->mbmi.mode;
386
387 if (xd->mode_info_context->mbmi.mb_skip_coeff) {
388 vp9_reset_mb_tokens_context(xd);
389 } else if (!bool_error(bc)) {
390 for (i = 0; i < 25; i++) {
391 xd->block[i].eob = 0;
392 xd->eobs[i] = 0;
393 }
394 if (tx_size == TX_16X16) {
395 eobtotal = vp9_decode_mb_tokens_16x16(pbi, xd, bc);
396 } else if (tx_size == TX_8X8) {
397 eobtotal = vp9_decode_mb_tokens_8x8(pbi, xd, bc);
398 } else {
399 eobtotal = vp9_decode_mb_tokens_4x4(pbi, xd, bc);
400 }
401 }
402
403 //mode = xd->mode_info_context->mbmi.mode;
404 if (pbi->common.frame_type != KEY_FRAME)
405 vp9_setup_interp_filters(xd, xd->mode_info_context->mbmi.interp_filter,
406 &pbi->common);
407
408 if (eobtotal == 0 && mode != B_PRED && mode != SPLITMV
409 && mode != I8X8_PRED
410 && !bool_error(bc)) {
411 /* Special case: Force the loopfilter to skip when eobtotal and
412 * mb_skip_coeff are zero.
413 * */
414 xd->mode_info_context->mbmi.mb_skip_coeff = 1;
415 skip_recon_mb(pbi, xd);
416 return;
417 }
418
419 // moved to be performed before detokenization
420 // if (xd->segmentation_enabled)
421 // mb_init_dequantizer(pbi, xd);
422
423 /* do prediction */
424 if (xd->mode_info_context->mbmi.ref_frame == INTRA_FRAME) {
425 if (mode != I8X8_PRED) {
426 vp9_build_intra_predictors_mbuv(xd);
427 if (mode != B_PRED) {
428 vp9_build_intra_predictors_mby(xd);
429 }
430 }
431 } else {
432 vp9_build_inter_predictors_mb(xd);
433 }
434
435 /* dequantization and idct */
436 if (mode == I8X8_PRED) {
437 for (i = 0; i < 4; i++) {
438 int ib = vp9_i8x8_block[i];
439 const int iblock[4] = {0, 1, 4, 5};
440 int j;
441 int i8x8mode;
442 BLOCKD *b;
443
444 int idx = (ib & 0x02) ? (ib + 2) : ib;
445
446 short *q = xd->block[idx].qcoeff;
447 short *dq = xd->block[0].dequant;
448 unsigned char *pre = xd->block[ib].predictor;
449 unsigned char *dst = *(xd->block[ib].base_dst) + xd->block[ib].dst;
450 int stride = xd->dst.y_stride;
451
452 b = &xd->block[ib];
453 i8x8mode = b->bmi.as_mode.first;
454 vp9_intra8x8_predict(b, i8x8mode, b->predictor);
455
456 if (xd->mode_info_context->mbmi.txfm_size == TX_8X8) {
457 tx_type = get_tx_type(xd, &xd->block[idx]);
458 if (tx_type != DCT_DCT) {
459 vp9_ht_dequant_idct_add_8x8_c(tx_type,
460 q, dq, pre, dst, 16, stride);
461 } else {
462 vp9_dequant_idct_add_8x8_c(q, dq, pre, dst, 16, stride, 0,
463 xd->eobs[idx]);
464 }
465 q += 64;
466 } else {
467 for (j = 0; j < 4; j++) {
468 b = &xd->block[ib + iblock[j]];
469 vp9_dequant_idct_add(b->qcoeff, b->dequant, b->predictor,
470 *(b->base_dst) + b->dst, 16, b->dst_stride);
471 }
472 }
473 b = &xd->block[16 + i];
474 vp9_intra_uv4x4_predict(b, i8x8mode, b->predictor);
475 pbi->idct_add(b->qcoeff, b->dequant, b->predictor,
476 *(b->base_dst) + b->dst, 8, b->dst_stride);
477 b = &xd->block[20 + i];
478 vp9_intra_uv4x4_predict(b, i8x8mode, b->predictor);
479 pbi->idct_add(b->qcoeff, b->dequant, b->predictor,
480 *(b->base_dst) + b->dst, 8, b->dst_stride);
481 }
482 } else if (mode == B_PRED) {
483 for (i = 0; i < 16; i++) {
484 int b_mode;
485 #if CONFIG_COMP_INTRA_PRED
486 int b_mode2;
487 #endif
488 BLOCKD *b = &xd->block[i];
489 b_mode = xd->mode_info_context->bmi[i].as_mode.first;
490 #if CONFIG_NEWBINTRAMODES
491 xd->mode_info_context->bmi[i].as_mode.context = b->bmi.as_mode.context =
492 vp9_find_bpred_context(b);
493 #endif
494 #if CONFIG_COMP_INTRA_PRED
495 b_mode2 = xd->mode_info_context->bmi[i].as_mode.second;
496
497 if (b_mode2 == (B_PREDICTION_MODE)(B_DC_PRED - 1)) {
498 #endif
499 vp9_intra4x4_predict(b, b_mode, b->predictor);
500 #if CONFIG_COMP_INTRA_PRED
501 } else {
502 vp9_comp_intra4x4_predict(b, b_mode, b_mode2, b->predictor);
503 }
504 #endif
505
506 tx_type = get_tx_type(xd, b);
507 if (tx_type != DCT_DCT) {
508 vp9_ht_dequant_idct_add_c(tx_type, b->qcoeff,
509 b->dequant, b->predictor,
510 *(b->base_dst) + b->dst, 16, b->dst_stride);
511 } else {
512 vp9_dequant_idct_add(b->qcoeff, b->dequant, b->predictor,
513 *(b->base_dst) + b->dst, 16, b->dst_stride);
514 }
515 }
516 } else if (mode == SPLITMV) {
517 if (tx_size == TX_8X8) {
518 vp9_dequant_idct_add_y_block_8x8(xd->qcoeff, xd->block[0].dequant,
519 xd->predictor, xd->dst.y_buffer,
520 xd->dst.y_stride, xd->eobs, xd);
521 } else {
522 pbi->idct_add_y_block(xd->qcoeff, xd->block[0].dequant,
523 xd->predictor, xd->dst.y_buffer,
524 xd->dst.y_stride, xd->eobs);
525 }
526 } else {
527 BLOCKD *b = &xd->block[24];
528
529 if (tx_size == TX_16X16) {
530 BLOCKD *bd = &xd->block[0];
531 tx_type = get_tx_type(xd, bd);
532 if (tx_type != DCT_DCT) {
533 vp9_ht_dequant_idct_add_16x16_c(tx_type, xd->qcoeff,
534 xd->block[0].dequant, xd->predictor,
535 xd->dst.y_buffer, 16, xd->dst.y_stride);
536 } else {
537 vp9_dequant_idct_add_16x16(xd->qcoeff, xd->block[0].dequant,
538 xd->predictor, xd->dst.y_buffer,
539 16, xd->dst.y_stride, xd->eobs[0]);
540 }
541 } else if (tx_size == TX_8X8) {
542 vp9_dequantize_b_2x2(b);
543 IDCT_INVOKE(RTCD_VTABLE(idct), ihaar2)(&b->dqcoeff[0], b->diff, 8);
544 ((int *)b->qcoeff)[0] = 0; // 2nd order block are set to 0 after idct
545 ((int *)b->qcoeff)[1] = 0;
546 ((int *)b->qcoeff)[2] = 0;
547 ((int *)b->qcoeff)[3] = 0;
548 ((int *)b->qcoeff)[4] = 0;
549 ((int *)b->qcoeff)[5] = 0;
550 ((int *)b->qcoeff)[6] = 0;
551 ((int *)b->qcoeff)[7] = 0;
552 vp9_dequant_dc_idct_add_y_block_8x8(xd->qcoeff,
553 xd->block[0].dequant, xd->predictor, xd->dst.y_buffer,
554 xd->dst.y_stride, xd->eobs, xd->block[24].diff, xd);
555 } else {
556 vp9_dequantize_b(b);
557 if (xd->eobs[24] > 1) {
558 IDCT_INVOKE(RTCD_VTABLE(idct), iwalsh16)(&b->dqcoeff[0], b->diff);
559 ((int *)b->qcoeff)[0] = 0;
560 ((int *)b->qcoeff)[1] = 0;
561 ((int *)b->qcoeff)[2] = 0;
562 ((int *)b->qcoeff)[3] = 0;
563 ((int *)b->qcoeff)[4] = 0;
564 ((int *)b->qcoeff)[5] = 0;
565 ((int *)b->qcoeff)[6] = 0;
566 ((int *)b->qcoeff)[7] = 0;
567 } else {
568 IDCT_INVOKE(RTCD_VTABLE(idct), iwalsh1)(&b->dqcoeff[0], b->diff);
569 ((int *)b->qcoeff)[0] = 0;
570 }
571
572 pbi->dc_idct_add_y_block(xd->qcoeff, xd->block[0].dequant, xd->predictor,
573 xd->dst.y_buffer, xd->dst.y_stride, xd->eobs,
574 xd->block[24].diff);
575 }
576 }
577
578 if ((tx_size == TX_8X8 &&
579 xd->mode_info_context->mbmi.mode != I8X8_PRED &&
580 xd->mode_info_context->mbmi.mode != SPLITMV)
581 || tx_size == TX_16X16
582 )
583 vp9_dequant_idct_add_uv_block_8x8
584 (xd->qcoeff + 16 * 16, xd->block[16].dequant,
585 xd->predictor + 16 * 16, xd->dst.u_buffer, xd->dst.v_buffer,
586 xd->dst.uv_stride, xd->eobs + 16, xd);
587 else if (xd->mode_info_context->mbmi.mode != I8X8_PRED)
588 pbi->idct_add_uv_block(xd->qcoeff + 16 * 16, xd->block[16].dequant,
589 xd->predictor + 16 * 16, xd->dst.u_buffer, xd->dst.v_buffer,
590 xd->dst.uv_stride, xd->eobs + 16);
591 }
592
593
594 static int get_delta_q(vp9_reader *bc, int prev, int *q_update) {
595 int ret_val = 0;
596
597 if (vp9_read_bit(bc)) {
598 ret_val = vp9_read_literal(bc, 4);
599
600 if (vp9_read_bit(bc))
601 ret_val = -ret_val;
602 }
603
604 /* Trigger a quantizer update if the delta-q value has changed */
605 if (ret_val != prev)
606 *q_update = 1;
607
608 return ret_val;
609 }
610
611 #ifdef PACKET_TESTING
612 #include <stdio.h>
613 FILE *vpxlog = 0;
614 #endif
615
616 /* Decode a row of Superblocks (2x2 region of MBs) */
617 static void
618 decode_sb_row(VP9D_COMP *pbi, VP9_COMMON *pc, int mbrow, MACROBLOCKD *xd,
619 BOOL_DECODER* const bc) {
620 int i;
621 int sb_col;
622 int mb_row, mb_col;
623 int recon_yoffset, recon_uvoffset;
624 int ref_fb_idx = pc->lst_fb_idx;
625 int dst_fb_idx = pc->new_fb_idx;
626 int recon_y_stride = pc->yv12_fb[ref_fb_idx].y_stride;
627 int recon_uv_stride = pc->yv12_fb[ref_fb_idx].uv_stride;
628 int row_delta[4] = { 0, +1, 0, -1};
629 int col_delta[4] = { +1, -1, +1, +1};
630 int sb_cols = (pc->mb_cols + 1) >> 1;
631
632 // For a SB there are 2 left contexts, each pertaining to a MB row within
633 vpx_memset(pc->left_context, 0, sizeof(pc->left_context));
634
635 mb_row = mbrow;
636 mb_col = 0;
637
638 for (sb_col = 0; sb_col < sb_cols; sb_col++) {
639 MODE_INFO *mi = xd->mode_info_context;
640
641 #if CONFIG_SUPERBLOCKS
642 mi->mbmi.encoded_as_sb = vp9_read(bc, pc->sb_coded);
643 #endif
644
645 // Process the 4 MBs within the SB in the order:
646 // top-left, top-right, bottom-left, bottom-right
647 for (i = 0; i < 4; i++) {
648 int dy = row_delta[i];
649 int dx = col_delta[i];
650 int offset_extended = dy * xd->mode_info_stride + dx;
651
652 xd->mb_index = i;
653
654 mi = xd->mode_info_context;
655 if ((mb_row >= pc->mb_rows) || (mb_col >= pc->mb_cols)) {
656 // MB lies outside frame, skip on to next
657 mb_row += dy;
658 mb_col += dx;
659 xd->mode_info_context += offset_extended;
660 xd->prev_mode_info_context += offset_extended;
661 continue;
662 }
663 #if CONFIG_SUPERBLOCKS
664 if (i)
665 mi->mbmi.encoded_as_sb = 0;
666 #endif
667
668 // Set above context pointer
669 xd->above_context = pc->above_context + mb_col;
670 xd->left_context = pc->left_context + (i >> 1);
671
672 /* Distance of Mb to the various image edges.
673 * These are specified to 8th pel as they are always compared to
674 * values that are in 1/8th pel units
675 */
676 xd->mb_to_top_edge = -((mb_row * 16)) << 3;
677 xd->mb_to_left_edge = -((mb_col * 16) << 3);
678 #if CONFIG_SUPERBLOCKS
679 if (mi->mbmi.encoded_as_sb) {
680 xd->mb_to_bottom_edge = ((pc->mb_rows - 2 - mb_row) * 16) << 3;
681 xd->mb_to_right_edge = ((pc->mb_cols - 2 - mb_col) * 16) << 3;
682 } else {
683 #endif
684 xd->mb_to_bottom_edge = ((pc->mb_rows - 1 - mb_row) * 16) << 3;
685 xd->mb_to_right_edge = ((pc->mb_cols - 1 - mb_col) * 16) << 3;
686 #if CONFIG_SUPERBLOCKS
687 }
688 #endif
689
690 xd->up_available = (mb_row != 0);
691 xd->left_available = (mb_col != 0);
692
693
694 recon_yoffset = (mb_row * recon_y_stride * 16) + (mb_col * 16);
695 recon_uvoffset = (mb_row * recon_uv_stride * 8) + (mb_col * 8);
696
697 xd->dst.y_buffer = pc->yv12_fb[dst_fb_idx].y_buffer + recon_yoffset;
698 xd->dst.u_buffer = pc->yv12_fb[dst_fb_idx].u_buffer + recon_uvoffset;
699 xd->dst.v_buffer = pc->yv12_fb[dst_fb_idx].v_buffer + recon_uvoffset;
700
701 vp9_decode_mb_mode_mv(pbi, xd, mb_row, mb_col, bc);
702
703 update_blockd_bmi(xd);
704
705 /* Select the appropriate reference frame for this MB */
706 if (xd->mode_info_context->mbmi.ref_frame == LAST_FRAME)
707 ref_fb_idx = pc->lst_fb_idx;
708 else if (xd->mode_info_context->mbmi.ref_frame == GOLDEN_FRAME)
709 ref_fb_idx = pc->gld_fb_idx;
710 else
711 ref_fb_idx = pc->alt_fb_idx;
712
713 xd->pre.y_buffer = pc->yv12_fb[ref_fb_idx].y_buffer + recon_yoffset;
714 xd->pre.u_buffer = pc->yv12_fb[ref_fb_idx].u_buffer + recon_uvoffset;
715 xd->pre.v_buffer = pc->yv12_fb[ref_fb_idx].v_buffer + recon_uvoffset;
716
717 if (xd->mode_info_context->mbmi.second_ref_frame > 0) {
718 int second_ref_fb_idx;
719
720 /* Select the appropriate reference frame for this MB */
721 if (xd->mode_info_context->mbmi.second_ref_frame == LAST_FRAME)
722 second_ref_fb_idx = pc->lst_fb_idx;
723 else if (xd->mode_info_context->mbmi.second_ref_frame ==
724 GOLDEN_FRAME)
725 second_ref_fb_idx = pc->gld_fb_idx;
726 else
727 second_ref_fb_idx = pc->alt_fb_idx;
728
729 xd->second_pre.y_buffer =
730 pc->yv12_fb[second_ref_fb_idx].y_buffer + recon_yoffset;
731 xd->second_pre.u_buffer =
732 pc->yv12_fb[second_ref_fb_idx].u_buffer + recon_uvoffset;
733 xd->second_pre.v_buffer =
734 pc->yv12_fb[second_ref_fb_idx].v_buffer + recon_uvoffset;
735 }
736
737 if (xd->mode_info_context->mbmi.ref_frame != INTRA_FRAME) {
738 /* propagate errors from reference frames */
739 xd->corrupted |= pc->yv12_fb[ref_fb_idx].corrupted;
740 }
741
742 #if CONFIG_SUPERBLOCKS
743 if (xd->mode_info_context->mbmi.encoded_as_sb) {
744 if (mb_col < pc->mb_cols - 1)
745 mi[1] = mi[0];
746 if (mb_row < pc->mb_rows - 1) {
747 mi[pc->mode_info_stride] = mi[0];
748 if (mb_col < pc->mb_cols - 1)
749 mi[pc->mode_info_stride + 1] = mi[0];
750 }
751 }
752 if (xd->mode_info_context->mbmi.encoded_as_sb) {
753 decode_superblock(pbi, xd, mb_row, mb_col, bc);
754 } else {
755 #endif
756 vp9_intra_prediction_down_copy(xd);
757 decode_macroblock(pbi, xd, mb_row, mb_col, bc);
758 #if CONFIG_SUPERBLOCKS
759 }
760 #endif
761
762 /* check if the boolean decoder has suffered an error */
763 xd->corrupted |= bool_error(bc);
764
765 #if CONFIG_SUPERBLOCKS
766 if (mi->mbmi.encoded_as_sb) {
767 assert(!i);
768 mb_col += 2;
769 xd->mode_info_context += 2;
770 xd->prev_mode_info_context += 2;
771 break;
772 }
773 #endif
774
775 // skip to next MB
776 xd->mode_info_context += offset_extended;
777 xd->prev_mode_info_context += offset_extended;
778 mb_row += dy;
779 mb_col += dx;
780 }
781 }
782
783 /* skip prediction column */
784 xd->mode_info_context += 1 - (pc->mb_cols & 0x1) + xd->mode_info_stride;
785 xd->prev_mode_info_context += 1 - (pc->mb_cols & 0x1) + xd->mode_info_stride;
786 }
787
788 static unsigned int read_partition_size(const unsigned char *cx_size) {
789 const unsigned int size =
790 cx_size[0] + (cx_size[1] << 8) + (cx_size[2] << 16);
791 return size;
792 }
793
794 static int read_is_valid(const unsigned char *start,
795 size_t len,
796 const unsigned char *end) {
797 return (start + len > start && start + len <= end);
798 }
799
800
801 static void setup_token_decoder(VP9D_COMP *pbi,
802 const unsigned char *cx_data,
803 BOOL_DECODER* const bool_decoder) {
804 VP9_COMMON *pc = &pbi->common;
805 const unsigned char *user_data_end = pbi->Source + pbi->source_sz;
806 const unsigned char *partition;
807
808 ptrdiff_t partition_size;
809 ptrdiff_t bytes_left;
810
811 // Set up pointers to token partition
812 partition = cx_data;
813 bytes_left = user_data_end - partition;
814 partition_size = bytes_left;
815
816 /* Validate the calculated partition length. If the buffer
817 * described by the partition can't be fully read, then restrict
818 * it to the portion that can be (for EC mode) or throw an error.
819 */
820 if (!read_is_valid(partition, partition_size, user_data_end)) {
821 vpx_internal_error(&pc->error, VPX_CODEC_CORRUPT_FRAME,
822 "Truncated packet or corrupt partition "
823 "%d length", 1);
824 }
825
826 if (vp9_start_decode(bool_decoder,
827 partition, (unsigned int)partition_size))
828 vpx_internal_error(&pc->error, VPX_CODEC_MEM_ERROR,
829 "Failed to allocate bool decoder %d", 1);
830 }
831
832 static void init_frame(VP9D_COMP *pbi) {
833 VP9_COMMON *const pc = &pbi->common;
834 MACROBLOCKD *const xd = &pbi->mb;
835
836 if (pc->frame_type == KEY_FRAME) {
837 /* Various keyframe initializations */
838 vp9_init_mv_probs(pc);
839
840 vp9_init_mbmode_probs(pc);
841 vp9_default_bmode_probs(pc->fc.bmode_prob);
842
843 vp9_default_coef_probs(pc);
844 vp9_kf_default_bmode_probs(pc->kf_bmode_prob);
845
846 // Reset the segment feature data to the default stats:
847 // Features disabled, 0, with delta coding (Default state).
848 vp9_clearall_segfeatures(xd);
849
850 xd->mb_segment_abs_delta = SEGMENT_DELTADATA;
851
852 /* reset the mode ref deltasa for loop filter */
853 vpx_memset(xd->ref_lf_deltas, 0, sizeof(xd->ref_lf_deltas));
854 vpx_memset(xd->mode_lf_deltas, 0, sizeof(xd->mode_lf_deltas));
855
856 /* All buffers are implicitly updated on key frames. */
857 pc->refresh_golden_frame = 1;
858 pc->refresh_alt_ref_frame = 1;
859 pc->copy_buffer_to_gf = 0;
860 pc->copy_buffer_to_arf = 0;
861
862 /* Note that Golden and Altref modes cannot be used on a key frame so
863 * ref_frame_sign_bias[] is undefined and meaningless
864 */
865 pc->ref_frame_sign_bias[GOLDEN_FRAME] = 0;
866 pc->ref_frame_sign_bias[ALTREF_FRAME] = 0;
867
868 vp9_init_mode_contexts(&pbi->common);
869 vpx_memcpy(&pc->lfc, &pc->fc, sizeof(pc->fc));
870 vpx_memcpy(&pc->lfc_a, &pc->fc, sizeof(pc->fc));
871
872 vpx_memcpy(pbi->common.fc.vp9_mode_contexts,
873 pbi->common.fc.mode_context,
874 sizeof(pbi->common.fc.mode_context));
875 vpx_memset(pc->prev_mip, 0,
876 (pc->mb_cols + 1) * (pc->mb_rows + 1)* sizeof(MODE_INFO));
877 vpx_memset(pc->mip, 0,
878 (pc->mb_cols + 1) * (pc->mb_rows + 1)* sizeof(MODE_INFO));
879
880 vp9_update_mode_info_border(pc, pc->mip);
881 vp9_update_mode_info_in_image(pc, pc->mi);
882
883 } else {
884
885 if (!pc->use_bilinear_mc_filter)
886 pc->mcomp_filter_type = EIGHTTAP;
887 else
888 pc->mcomp_filter_type = BILINEAR;
889
890 /* To enable choice of different interpolation filters */
891 vp9_setup_interp_filters(xd, pc->mcomp_filter_type, pc);
892 }
893
894 xd->mode_info_context = pc->mi;
895 xd->prev_mode_info_context = pc->prev_mi;
896 xd->frame_type = pc->frame_type;
897 xd->mode_info_context->mbmi.mode = DC_PRED;
898 xd->mode_info_stride = pc->mode_info_stride;
899 xd->corrupted = 0; /* init without corruption */
900
901 xd->fullpixel_mask = 0xffffffff;
902 if (pc->full_pixel)
903 xd->fullpixel_mask = 0xfffffff8;
904
905 }
906
907 #if 0
908 static void read_coef_probs2(VP9D_COMP *pbi) {
909 const vp9_prob grpupd = 192;
910 int i, j, k, l;
911 vp9_reader *const bc = &pbi->bc;
912 VP9_COMMON *const pc = &pbi->common;
913 for (l = 0; l < ENTROPY_NODES; l++) {
914 if (vp9_read(bc, grpupd)) {
915 // printf("Decoding %d\n", l);
916 for (i = 0; i < BLOCK_TYPES; i++)
917 for (j = !i; j < COEF_BANDS; j++)
918 for (k = 0; k < PREV_COEF_CONTEXTS; k++) {
919 if (k >= 3 && ((i == 0 && j == 1) ||
920 (i > 0 && j == 0)))
921 continue;
922 {
923 vp9_prob *const p = pc->fc.coef_probs [i][j][k] + l;
924 int u = vp9_read(bc, COEF_UPDATE_PROB);
925 if (u) *p = read_prob_diff_update(bc, *p);
926 }
927 }
928 }
929 }
930 if (pbi->common.txfm_mode == ALLOW_8X8) {
931 for (l = 0; l < ENTROPY_NODES; l++) {
932 if (vp9_read(bc, grpupd)) {
933 for (i = 0; i < BLOCK_TYPES_8X8; i++)
934 for (j = !i; j < COEF_BANDS; j++)
935 for (k = 0; k < PREV_COEF_CONTEXTS; k++) {
936 if (k >= 3 && ((i == 0 && j == 1) ||
937 (i > 0 && j == 0)))
938 continue;
939 {
940 vp9_prob *const p = pc->fc.coef_probs_8x8 [i][j][k] + l;
941
942 int u = vp9_read(bc, COEF_UPDATE_PROB_8X8);
943 if (u) *p = read_prob_diff_update(bc, *p);
944 }
945 }
946 }
947 }
948 }
949 }
950 #endif
951
952 static void read_coef_probs_common(
953 BOOL_DECODER* const bc,
954 vp9_prob coef_probs[BLOCK_TYPES][COEF_BANDS]
955 [PREV_COEF_CONTEXTS][ENTROPY_NODES]) {
956 int i, j, k, l;
957
958 if (vp9_read_bit(bc)) {
959 for (i = 0; i < BLOCK_TYPES; i++) {
960 for (j = !i; j < COEF_BANDS; j++) {
961 /* NB: This j loop starts from 1 on block type i == 0 */
962 for (k = 0; k < PREV_COEF_CONTEXTS; k++) {
963 if (k >= 3 && ((i == 0 && j == 1) ||
964 (i > 0 && j == 0)))
965 continue;
966 for (l = 0; l < ENTROPY_NODES; l++) {
967 vp9_prob *const p = coef_probs[i][j][k] + l;
968
969 if (vp9_read(bc, COEF_UPDATE_PROB)) {
970 *p = read_prob_diff_update(bc, *p);
971 }
972 }
973 }
974 }
975 }
976 }
977 }
978
979 static void read_coef_probs(VP9D_COMP *pbi, BOOL_DECODER* const bc) {
980 VP9_COMMON *const pc = &pbi->common;
981
982 read_coef_probs_common(bc, pc->fc.coef_probs);
983 read_coef_probs_common(bc, pc->fc.hybrid_coef_probs);
984
985 if (pbi->common.txfm_mode != ONLY_4X4) {
986 read_coef_probs_common(bc, pc->fc.coef_probs_8x8);
987 read_coef_probs_common(bc, pc->fc.hybrid_coef_probs_8x8);
988 }
989 if (pbi->common.txfm_mode > ALLOW_8X8) {
990 read_coef_probs_common(bc, pc->fc.coef_probs_16x16);
991 read_coef_probs_common(bc, pc->fc.hybrid_coef_probs_16x16);
992 }
993 }
994
995 int vp9_decode_frame(VP9D_COMP *pbi, const unsigned char **p_data_end) {
996 BOOL_DECODER header_bc, residual_bc;
997 VP9_COMMON *const pc = &pbi->common;
998 MACROBLOCKD *const xd = &pbi->mb;
999 const unsigned char *data = (const unsigned char *)pbi->Source;
1000 const unsigned char *data_end = data + pbi->source_sz;
1001 ptrdiff_t first_partition_length_in_bytes = 0;
1002
1003 int mb_row;
1004 int i, j;
1005 int corrupt_tokens = 0;
1006
1007 /* start with no corruption of current frame */
1008 xd->corrupted = 0;
1009 pc->yv12_fb[pc->new_fb_idx].corrupted = 0;
1010
1011 if (data_end - data < 3) {
1012 vpx_internal_error(&pc->error, VPX_CODEC_CORRUPT_FRAME,
1013 "Truncated packet");
1014 } else {
1015 pc->last_frame_type = pc->frame_type;
1016 pc->frame_type = (FRAME_TYPE)(data[0] & 1);
1017 pc->version = (data[0] >> 1) & 7;
1018 pc->show_frame = (data[0] >> 4) & 1;
1019 first_partition_length_in_bytes =
1020 (data[0] | (data[1] << 8) | (data[2] << 16)) >> 5;
1021
1022 if ((data + first_partition_length_in_bytes > data_end
1023 || data + first_partition_length_in_bytes < data))
1024 vpx_internal_error(&pc->error, VPX_CODEC_CORRUPT_FRAME,
1025 "Truncated packet or corrupt partition 0 length");
1026
1027 data += 3;
1028
1029 vp9_setup_version(pc);
1030
1031 if (pc->frame_type == KEY_FRAME) {
1032 const int Width = pc->Width;
1033 const int Height = pc->Height;
1034
1035 /* vet via sync code */
1036 /* When error concealment is enabled we should only check the sync
1037 * code if we have enough bits available
1038 */
1039 if (data + 3 < data_end) {
1040 if (data[0] != 0x9d || data[1] != 0x01 || data[2] != 0x2a)
1041 vpx_internal_error(&pc->error, VPX_CODEC_UNSUP_BITSTREAM,
1042 "Invalid frame sync code");
1043 }
1044
1045 /* If error concealment is enabled we should only parse the new size
1046 * if we have enough data. Otherwise we will end up with the wrong
1047 * size.
1048 */
1049 if (data + 6 < data_end) {
1050 pc->Width = (data[3] | (data[4] << 8)) & 0x3fff;
1051 pc->horiz_scale = data[4] >> 6;
1052 pc->Height = (data[5] | (data[6] << 8)) & 0x3fff;
1053 pc->vert_scale = data[6] >> 6;
1054 }
1055 data += 7;
1056
1057 if (Width != pc->Width || Height != pc->Height) {
1058 if (pc->Width <= 0) {
1059 pc->Width = Width;
1060 vpx_internal_error(&pc->error, VPX_CODEC_CORRUPT_FRAME,
1061 "Invalid frame width");
1062 }
1063
1064 if (pc->Height <= 0) {
1065 pc->Height = Height;
1066 vpx_internal_error(&pc->error, VPX_CODEC_CORRUPT_FRAME,
1067 "Invalid frame height");
1068 }
1069
1070 if (vp9_alloc_frame_buffers(pc, pc->Width, pc->Height))
1071 vpx_internal_error(&pc->error, VPX_CODEC_MEM_ERROR,
1072 "Failed to allocate frame buffers");
1073 }
1074 }
1075 }
1076
1077 if ((!pbi->decoded_key_frame && pc->frame_type != KEY_FRAME) ||
1078 pc->Width == 0 || pc->Height == 0) {
1079 return -1;
1080 }
1081
1082 init_frame(pbi);
1083
1084 if (vp9_start_decode(&header_bc, data,
1085 (unsigned int)first_partition_length_in_bytes))
1086 vpx_internal_error(&pc->error, VPX_CODEC_MEM_ERROR,
1087 "Failed to allocate bool decoder 0");
1088 if (pc->frame_type == KEY_FRAME) {
1089 pc->clr_type = (YUV_TYPE)vp9_read_bit(&header_bc);
1090 pc->clamp_type = (CLAMP_TYPE)vp9_read_bit(&header_bc);
1091 }
1092
1093 /* Is segmentation enabled */
1094 xd->segmentation_enabled = (unsigned char)vp9_read_bit(&header_bc);
1095
1096 if (xd->segmentation_enabled) {
1097 // Read whether or not the segmentation map is being explicitly
1098 // updated this frame.
1099 xd->update_mb_segmentation_map = (unsigned char)vp9_read_bit(&header_bc);
1100
1101 // If so what method will be used.
1102 if (xd->update_mb_segmentation_map) {
1103 // Which macro block level features are enabled
1104
1105 // Read the probs used to decode the segment id for each macro
1106 // block.
1107 for (i = 0; i < MB_FEATURE_TREE_PROBS; i++) {
1108 xd->mb_segment_tree_probs[i] = vp9_read_bit(&header_bc) ?
1109 (vp9_prob)vp9_read_literal(&header_bc, 8) : 255;
1110 }
1111
1112 // Read the prediction probs needed to decode the segment id
1113 pc->temporal_update = (unsigned char)vp9_read_bit(&header_bc);
1114 for (i = 0; i < PREDICTION_PROBS; i++) {
1115 if (pc->temporal_update) {
1116 pc->segment_pred_probs[i] = vp9_read_bit(&header_bc) ?
1117 (vp9_prob)vp9_read_literal(&header_bc, 8) : 255;
1118 } else {
1119 pc->segment_pred_probs[i] = 255;
1120 }
1121 }
1122 }
1123 // Is the segment data being updated
1124 xd->update_mb_segmentation_data = (unsigned char)vp9_read_bit(&header_bc);
1125
1126 if (xd->update_mb_segmentation_data) {
1127 int data;
1128
1129 xd->mb_segment_abs_delta = (unsigned char)vp9_read_bit(&header_bc);
1130
1131 vp9_clearall_segfeatures(xd);
1132
1133 // For each segmentation...
1134 for (i = 0; i < MAX_MB_SEGMENTS; i++) {
1135 // For each of the segments features...
1136 for (j = 0; j < SEG_LVL_MAX; j++) {
1137 // Is the feature enabled
1138 if (vp9_read_bit(&header_bc)) {
1139 // Update the feature data and mask
1140 vp9_enable_segfeature(xd, i, j);
1141
1142 data = (signed char)vp9_read_literal(
1143 &header_bc, vp9_seg_feature_data_bits(j));
1144
1145 // Is the segment data signed..
1146 if (vp9_is_segfeature_signed(j)) {
1147 if (vp9_read_bit(&header_bc))
1148 data = - data;
1149 }
1150 } else
1151 data = 0;
1152
1153 vp9_set_segdata(xd, i, j, data);
1154 }
1155 }
1156 }
1157 }
1158
1159 // Read common prediction model status flag probability updates for the
1160 // reference frame
1161 if (pc->frame_type == KEY_FRAME) {
1162 // Set the prediction probabilities to defaults
1163 pc->ref_pred_probs[0] = 120;
1164 pc->ref_pred_probs[1] = 80;
1165 pc->ref_pred_probs[2] = 40;
1166 } else {
1167 for (i = 0; i < PREDICTION_PROBS; i++) {
1168 if (vp9_read_bit(&header_bc))
1169 pc->ref_pred_probs[i] = (vp9_prob)vp9_read_literal(&header_bc, 8);
1170 }
1171 }
1172
1173 #if CONFIG_SUPERBLOCKS
1174 pc->sb_coded = vp9_read_literal(&header_bc, 8);
1175 #endif
1176
1177 /* Read the loop filter level and type */
1178 pc->txfm_mode = vp9_read_literal(&header_bc, 2);
1179 if (pc->txfm_mode == TX_MODE_SELECT) {
1180 pc->prob_tx[0] = vp9_read_literal(&header_bc, 8);
1181 pc->prob_tx[1] = vp9_read_literal(&header_bc, 8);
1182 }
1183
1184 pc->filter_type = (LOOPFILTERTYPE) vp9_read_bit(&header_bc);
1185 pc->filter_level = vp9_read_literal(&header_bc, 6);
1186 pc->sharpness_level = vp9_read_literal(&header_bc, 3);
1187
1188 /* Read in loop filter deltas applied at the MB level based on mode or ref frame. */
1189 xd->mode_ref_lf_delta_update = 0;
1190 xd->mode_ref_lf_delta_enabled = (unsigned char)vp9_read_bit(&header_bc);
1191
1192 if (xd->mode_ref_lf_delta_enabled) {
1193 /* Do the deltas need to be updated */
1194 xd->mode_ref_lf_delta_update = (unsigned char)vp9_read_bit(&header_bc);
1195
1196 if (xd->mode_ref_lf_delta_update) {
1197 /* Send update */
1198 for (i = 0; i < MAX_REF_LF_DELTAS; i++) {
1199 if (vp9_read_bit(&header_bc)) {
1200 /*sign = vp9_read_bit( &header_bc );*/
1201 xd->ref_lf_deltas[i] = (signed char)vp9_read_literal(&header_bc, 6);
1202
1203 if (vp9_read_bit(&header_bc)) /* Apply sign */
1204 xd->ref_lf_deltas[i] = xd->ref_lf_deltas[i] * -1;
1205 }
1206 }
1207
1208 /* Send update */
1209 for (i = 0; i < MAX_MODE_LF_DELTAS; i++) {
1210 if (vp9_read_bit(&header_bc)) {
1211 /*sign = vp9_read_bit( &header_bc );*/
1212 xd->mode_lf_deltas[i] = (signed char)vp9_read_literal(&header_bc, 6);
1213
1214 if (vp9_read_bit(&header_bc)) /* Apply sign */
1215 xd->mode_lf_deltas[i] = xd->mode_lf_deltas[i] * -1;
1216 }
1217 }
1218 }
1219 }
1220
1221 // Dummy read for now
1222 vp9_read_literal(&header_bc, 2);
1223
1224 setup_token_decoder(pbi, data + first_partition_length_in_bytes,
1225 &residual_bc);
1226
1227 /* Read the default quantizers. */
1228 {
1229 int Q, q_update;
1230
1231 Q = vp9_read_literal(&header_bc, QINDEX_BITS);
1232 pc->base_qindex = Q;
1233 q_update = 0;
1234 /* AC 1st order Q = default */
1235 pc->y1dc_delta_q = get_delta_q(&header_bc, pc->y1dc_delta_q, &q_update);
1236 pc->y2dc_delta_q = get_delta_q(&header_bc, pc->y2dc_delta_q, &q_update);
1237 pc->y2ac_delta_q = get_delta_q(&header_bc, pc->y2ac_delta_q, &q_update);
1238 pc->uvdc_delta_q = get_delta_q(&header_bc, pc->uvdc_delta_q, &q_update);
1239 pc->uvac_delta_q = get_delta_q(&header_bc, pc->uvac_delta_q, &q_update);
1240
1241 if (q_update)
1242 vp9_init_de_quantizer(pbi);
1243
1244 /* MB level dequantizer setup */
1245 mb_init_dequantizer(pbi, &pbi->mb);
1246 }
1247
1248 /* Determine if the golden frame or ARF buffer should be updated and how.
1249 * For all non key frames the GF and ARF refresh flags and sign bias
1250 * flags must be set explicitly.
1251 */
1252 if (pc->frame_type != KEY_FRAME) {
1253 /* Should the GF or ARF be updated from the current frame */
1254 pc->refresh_golden_frame = vp9_read_bit(&header_bc);
1255 pc->refresh_alt_ref_frame = vp9_read_bit(&header_bc);
1256
1257 if (pc->refresh_alt_ref_frame) {
1258 vpx_memcpy(&pc->fc, &pc->lfc_a, sizeof(pc->fc));
1259 vpx_memcpy(pc->fc.vp9_mode_contexts,
1260 pc->fc.mode_context_a,
1261 sizeof(pc->fc.vp9_mode_contexts));
1262 } else {
1263 vpx_memcpy(&pc->fc, &pc->lfc, sizeof(pc->fc));
1264 vpx_memcpy(pc->fc.vp9_mode_contexts,
1265 pc->fc.mode_context,
1266 sizeof(pc->fc.vp9_mode_contexts));
1267 }
1268
1269 /* Buffer to buffer copy flags. */
1270 pc->copy_buffer_to_gf = 0;
1271
1272 if (!pc->refresh_golden_frame)
1273 pc->copy_buffer_to_gf = vp9_read_literal(&header_bc, 2);
1274
1275 pc->copy_buffer_to_arf = 0;
1276
1277 if (!pc->refresh_alt_ref_frame)
1278 pc->copy_buffer_to_arf = vp9_read_literal(&header_bc, 2);
1279
1280 pc->ref_frame_sign_bias[GOLDEN_FRAME] = vp9_read_bit(&header_bc);
1281 pc->ref_frame_sign_bias[ALTREF_FRAME] = vp9_read_bit(&header_bc);
1282
1283 /* Is high precision mv allowed */
1284 xd->allow_high_precision_mv = (unsigned char)vp9_read_bit(&header_bc);
1285 // Read the type of subpel filter to use
1286 if (vp9_read_bit(&header_bc)) {
1287 pc->mcomp_filter_type = SWITCHABLE;
1288 } else {
1289 pc->mcomp_filter_type = vp9_read_literal(&header_bc, 2);
1290 }
1291 #if CONFIG_COMP_INTERINTRA_PRED
1292 pc->use_interintra = vp9_read_bit(&header_bc);
1293 #endif
1294 /* To enable choice of different interploation filters */
1295 vp9_setup_interp_filters(xd, pc->mcomp_filter_type, pc);
1296 }
1297
1298 pc->refresh_entropy_probs = vp9_read_bit(&header_bc);
1299 if (pc->refresh_entropy_probs == 0) {
1300 vpx_memcpy(&pc->lfc, &pc->fc, sizeof(pc->fc));
1301 }
1302
1303 pc->refresh_last_frame = (pc->frame_type == KEY_FRAME)
1304 || vp9_read_bit(&header_bc);
1305
1306 // Read inter mode probability context updates
1307 if (pc->frame_type != KEY_FRAME) {
1308 int i, j;
1309 for (i = 0; i < INTER_MODE_CONTEXTS; i++) {
1310 for (j = 0; j < 4; j++) {
1311 if (vp9_read(&header_bc, 252)) {
1312 pc->fc.vp9_mode_contexts[i][j] =
1313 (vp9_prob)vp9_read_literal(&header_bc, 8);
1314 }
1315 }
1316 }
1317 }
1318
1319 if (0) {
1320 FILE *z = fopen("decodestats.stt", "a");
1321 fprintf(z, "%6d F:%d,G:%d,A:%d,L:%d,Q:%d\n",
1322 pc->current_video_frame,
1323 pc->frame_type,
1324 pc->refresh_golden_frame,
1325 pc->refresh_alt_ref_frame,
1326 pc->refresh_last_frame,
1327 pc->base_qindex);
1328 fclose(z);
1329 }
1330
1331 vp9_copy(pbi->common.fc.pre_coef_probs,
1332 pbi->common.fc.coef_probs);
1333 vp9_copy(pbi->common.fc.pre_hybrid_coef_probs,
1334 pbi->common.fc.hybrid_coef_probs);
1335 vp9_copy(pbi->common.fc.pre_coef_probs_8x8,
1336 pbi->common.fc.coef_probs_8x8);
1337 vp9_copy(pbi->common.fc.pre_hybrid_coef_probs_8x8,
1338 pbi->common.fc.hybrid_coef_probs_8x8);
1339 vp9_copy(pbi->common.fc.pre_coef_probs_16x16,
1340 pbi->common.fc.coef_probs_16x16);
1341 vp9_copy(pbi->common.fc.pre_hybrid_coef_probs_16x16,
1342 pbi->common.fc.hybrid_coef_probs_16x16);
1343 vp9_copy(pbi->common.fc.pre_ymode_prob, pbi->common.fc.ymode_prob);
1344 #if CONFIG_SUPERBLOCKS
1345 vp9_copy(pbi->common.fc.pre_sb_ymode_prob, pbi->common.fc.sb_ymode_prob);
1346 #endif
1347 vp9_copy(pbi->common.fc.pre_uv_mode_prob, pbi->common.fc.uv_mode_prob);
1348 vp9_copy(pbi->common.fc.pre_bmode_prob, pbi->common.fc.bmode_prob);
1349 vp9_copy(pbi->common.fc.pre_i8x8_mode_prob, pbi->common.fc.i8x8_mode_prob);
1350 vp9_copy(pbi->common.fc.pre_sub_mv_ref_prob, pbi->common.fc.sub_mv_ref_prob);
1351 vp9_copy(pbi->common.fc.pre_mbsplit_prob, pbi->common.fc.mbsplit_prob);
1352 #if CONFIG_COMP_INTERINTRA_PRED
1353 pbi->common.fc.pre_interintra_prob = pbi->common.fc.interintra_prob;
1354 #endif
1355 pbi->common.fc.pre_nmvc = pbi->common.fc.nmvc;
1356 vp9_zero(pbi->common.fc.coef_counts);
1357 vp9_zero(pbi->common.fc.hybrid_coef_counts);
1358 vp9_zero(pbi->common.fc.coef_counts_8x8);
1359 vp9_zero(pbi->common.fc.hybrid_coef_counts_8x8);
1360 vp9_zero(pbi->common.fc.coef_counts_16x16);
1361 vp9_zero(pbi->common.fc.hybrid_coef_counts_16x16);
1362 vp9_zero(pbi->common.fc.ymode_counts);
1363 #if CONFIG_SUPERBLOCKS
1364 vp9_zero(pbi->common.fc.sb_ymode_counts);
1365 #endif
1366 vp9_zero(pbi->common.fc.uv_mode_counts);
1367 vp9_zero(pbi->common.fc.bmode_counts);
1368 vp9_zero(pbi->common.fc.i8x8_mode_counts);
1369 vp9_zero(pbi->common.fc.sub_mv_ref_counts);
1370 vp9_zero(pbi->common.fc.mbsplit_counts);
1371 vp9_zero(pbi->common.fc.NMVcount);
1372 vp9_zero(pbi->common.fc.mv_ref_ct);
1373 #if CONFIG_COMP_INTERINTRA_PRED
1374 vp9_zero(pbi->common.fc.interintra_counts);
1375 #endif
1376
1377 read_coef_probs(pbi, &header_bc);
1378
1379 vpx_memcpy(&xd->pre, &pc->yv12_fb[pc->lst_fb_idx], sizeof(YV12_BUFFER_CONFIG));
1380 vpx_memcpy(&xd->dst, &pc->yv12_fb[pc->new_fb_idx], sizeof(YV12_BUFFER_CONFIG));
1381
1382 // Create the segmentation map structure and set to 0
1383 if (!pc->last_frame_seg_map)
1384 CHECK_MEM_ERROR(pc->last_frame_seg_map,
1385 vpx_calloc((pc->mb_rows * pc->mb_cols), 1));
1386
1387 /* set up frame new frame for intra coded blocks */
1388 vp9_setup_intra_recon(&pc->yv12_fb[pc->new_fb_idx]);
1389
1390 vp9_setup_block_dptrs(xd);
1391
1392 vp9_build_block_doffsets(xd);
1393
1394 /* clear out the coeff buffer */
1395 vpx_memset(xd->qcoeff, 0, sizeof(xd->qcoeff));
1396
1397 /* Read the mb_no_coeff_skip flag */
1398 pc->mb_no_coeff_skip = (int)vp9_read_bit(&header_bc);
1399
1400 vp9_decode_mode_mvs_init(pbi, &header_bc);
1401
1402 vpx_memset(pc->above_context, 0, sizeof(ENTROPY_CONTEXT_PLANES) * pc->mb_cols);
1403
1404 // Resset the macroblock mode info context to the start of the list
1405 xd->mode_info_context = pc->mi;
1406 xd->prev_mode_info_context = pc->prev_mi;
1407
1408 /* Decode a row of superblocks */
1409 for (mb_row = 0; mb_row < pc->mb_rows; mb_row += 2) {
1410 decode_sb_row(pbi, pc, mb_row, xd, &residual_bc);
1411 }
1412 corrupt_tokens |= xd->corrupted;
1413
1414 /* Collect information about decoder corruption. */
1415 /* 1. Check first boolean decoder for errors. */
1416 pc->yv12_fb[pc->new_fb_idx].corrupted = bool_error(&header_bc);
1417 /* 2. Check the macroblock information */
1418 pc->yv12_fb[pc->new_fb_idx].corrupted |= corrupt_tokens;
1419
1420 if (!pbi->decoded_key_frame) {
1421 if (pc->frame_type == KEY_FRAME &&
1422 !pc->yv12_fb[pc->new_fb_idx].corrupted)
1423 pbi->decoded_key_frame = 1;
1424 else
1425 vpx_internal_error(&pbi->common.error, VPX_CODEC_CORRUPT_FRAME,
1426 "A stream must start with a complete key frame");
1427 }
1428
1429 vp9_adapt_coef_probs(pc);
1430 if (pc->frame_type != KEY_FRAME) {
1431 vp9_adapt_mode_probs(pc);
1432 vp9_adapt_nmv_probs(pc, xd->allow_high_precision_mv);
1433 vp9_update_mode_context(&pbi->common);
1434 }
1435
1436 /* If this was a kf or Gf note the Q used */
1437 if ((pc->frame_type == KEY_FRAME) ||
1438 pc->refresh_golden_frame || pc->refresh_alt_ref_frame) {
1439 pc->last_kf_gf_q = pc->base_qindex;
1440 }
1441 if (pc->refresh_entropy_probs) {
1442 if (pc->refresh_alt_ref_frame)
1443 vpx_memcpy(&pc->lfc_a, &pc->fc, sizeof(pc->fc));
1444 else
1445 vpx_memcpy(&pc->lfc, &pc->fc, sizeof(pc->fc));
1446 }
1447
1448 #ifdef PACKET_TESTING
1449 {
1450 FILE *f = fopen("decompressor.VP8", "ab");
1451 unsigned int size = residual_bc.pos + header_bc.pos + 8;
1452 fwrite((void *) &size, 4, 1, f);
1453 fwrite((void *) pbi->Source, size, 1, f);
1454 fclose(f);
1455 }
1456 #endif
1457 // printf("Frame %d Done\n", frame_count++);
1458
1459 /* Find the end of the coded buffer */
1460 while (residual_bc.count > CHAR_BIT
1461 && residual_bc.count < VP9_BD_VALUE_SIZE) {
1462 residual_bc.count -= CHAR_BIT;
1463 residual_bc.user_buffer--;
1464 }
1465 *p_data_end = residual_bc.user_buffer;
1466 return 0;
1467 }
AV1 Codec Library