1 /*
2 * Copyright (c) 2011 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 <assert.h>
12
13 #include "error_concealment.h"
14 #include "onyxd_int.h"
15 #include "decodemv.h"
16 #include "vpx_mem/vpx_mem.h"
17 #include "vp8/common/findnearmv.h"
18 #include "vp8/common/common.h"
19 #include "vpx_dsp/vpx_dsp_common.h"
20
21 #define FLOOR(x,q) ((x) & -(1 << (q)))
22
23 #define NUM_NEIGHBORS 20
24
25 typedef struct ec_position
26 {
27 int row;
28 int col;
29 } EC_POS;
30
31 /*
32 * Regenerate the table in Matlab with:
33 * x = meshgrid((1:4), (1:4));
34 * y = meshgrid((1:4), (1:4))';
35 * W = round((1./(sqrt(x.^2 + y.^2))*2^7));
36 * W(1,1) = 0;
37 */
38 static const int weights_q7[5][5] = {
39 { 0, 128, 64, 43, 32 },
40 {128, 91, 57, 40, 31 },
41 { 64, 57, 45, 36, 29 },
42 { 43, 40, 36, 30, 26 },
43 { 32, 31, 29, 26, 23 }
44 };
45
vp8_alloc_overlap_lists(VP8D_COMP * pbi)46 int vp8_alloc_overlap_lists(VP8D_COMP *pbi)
47 {
48 if (pbi->overlaps != NULL)
49 {
50 vpx_free(pbi->overlaps);
51 pbi->overlaps = NULL;
52 }
53
54 pbi->overlaps = vpx_calloc(pbi->common.mb_rows * pbi->common.mb_cols,
55 sizeof(MB_OVERLAP));
56
57 if (pbi->overlaps == NULL)
58 return -1;
59
60 return 0;
61 }
62
vp8_de_alloc_overlap_lists(VP8D_COMP * pbi)63 void vp8_de_alloc_overlap_lists(VP8D_COMP *pbi)
64 {
65 vpx_free(pbi->overlaps);
66 pbi->overlaps = NULL;
67 }
68
69 /* Inserts a new overlap area value to the list of overlaps of a block */
assign_overlap(OVERLAP_NODE * overlaps,union b_mode_info * bmi,int overlap)70 static void assign_overlap(OVERLAP_NODE* overlaps,
71 union b_mode_info *bmi,
72 int overlap)
73 {
74 int i;
75 if (overlap <= 0)
76 return;
77 /* Find and assign to the next empty overlap node in the list of overlaps.
78 * Empty is defined as bmi == NULL */
79 for (i = 0; i < MAX_OVERLAPS; i++)
80 {
81 if (overlaps[i].bmi == NULL)
82 {
83 overlaps[i].bmi = bmi;
84 overlaps[i].overlap = overlap;
85 break;
86 }
87 }
88 }
89
90 /* Calculates the overlap area between two 4x4 squares, where the first
91 * square has its upper-left corner at (b1_row, b1_col) and the second
92 * square has its upper-left corner at (b2_row, b2_col). Doesn't
93 * properly handle squares which do not overlap.
94 */
block_overlap(int b1_row,int b1_col,int b2_row,int b2_col)95 static int block_overlap(int b1_row, int b1_col, int b2_row, int b2_col)
96 {
97 const int int_top = VPXMAX(b1_row, b2_row); // top
98 const int int_left = VPXMAX(b1_col, b2_col); // left
99 /* Since each block is 4x4 pixels, adding 4 (Q3) to the left/top edge
100 * gives us the right/bottom edge.
101 */
102 const int int_right = VPXMIN(b1_col + (4<<3), b2_col + (4<<3)); // right
103 const int int_bottom = VPXMIN(b1_row + (4<<3), b2_row + (4<<3)); // bottom
104 return (int_bottom - int_top) * (int_right - int_left);
105 }
106
107 /* Calculates the overlap area for all blocks in a macroblock at position
108 * (mb_row, mb_col) in macroblocks, which are being overlapped by a given
109 * overlapping block at position (new_row, new_col) (in pixels, Q3). The
110 * first block being overlapped in the macroblock has position (first_blk_row,
111 * first_blk_col) in blocks relative the upper-left corner of the image.
112 */
calculate_overlaps_mb(B_OVERLAP * b_overlaps,union b_mode_info * bmi,int new_row,int new_col,int mb_row,int mb_col,int first_blk_row,int first_blk_col)113 static void calculate_overlaps_mb(B_OVERLAP *b_overlaps, union b_mode_info *bmi,
114 int new_row, int new_col,
115 int mb_row, int mb_col,
116 int first_blk_row, int first_blk_col)
117 {
118 /* Find the blocks within this MB (defined by mb_row, mb_col) which are
119 * overlapped by bmi and calculate and assign overlap for each of those
120 * blocks. */
121
122 /* Block coordinates relative the upper-left block */
123 const int rel_ol_blk_row = first_blk_row - mb_row * 4;
124 const int rel_ol_blk_col = first_blk_col - mb_col * 4;
125 /* If the block partly overlaps any previous MB, these coordinates
126 * can be < 0. We don't want to access blocks in previous MBs.
127 */
128 const int blk_idx = VPXMAX(rel_ol_blk_row,0) * 4 + VPXMAX(rel_ol_blk_col,0);
129 /* Upper left overlapping block */
130 B_OVERLAP *b_ol_ul = &(b_overlaps[blk_idx]);
131
132 /* Calculate and assign overlaps for all blocks in this MB
133 * which the motion compensated block overlaps
134 */
135 /* Avoid calculating overlaps for blocks in later MBs */
136 int end_row = VPXMIN(4 + mb_row * 4 - first_blk_row, 2);
137 int end_col = VPXMIN(4 + mb_col * 4 - first_blk_col, 2);
138 int row, col;
139
140 /* Check if new_row and new_col are evenly divisible by 4 (Q3),
141 * and if so we shouldn't check neighboring blocks
142 */
143 if (new_row >= 0 && (new_row & 0x1F) == 0)
144 end_row = 1;
145 if (new_col >= 0 && (new_col & 0x1F) == 0)
146 end_col = 1;
147
148 /* Check if the overlapping block partly overlaps a previous MB
149 * and if so, we're overlapping fewer blocks in this MB.
150 */
151 if (new_row < (mb_row*16)<<3)
152 end_row = 1;
153 if (new_col < (mb_col*16)<<3)
154 end_col = 1;
155
156 for (row = 0; row < end_row; ++row)
157 {
158 for (col = 0; col < end_col; ++col)
159 {
160 /* input in Q3, result in Q6 */
161 const int overlap = block_overlap(new_row, new_col,
162 (((first_blk_row + row) *
163 4) << 3),
164 (((first_blk_col + col) *
165 4) << 3));
166 assign_overlap(b_ol_ul[row * 4 + col].overlaps, bmi, overlap);
167 }
168 }
169 }
170
vp8_calculate_overlaps(MB_OVERLAP * overlap_ul,int mb_rows,int mb_cols,union b_mode_info * bmi,int b_row,int b_col)171 void vp8_calculate_overlaps(MB_OVERLAP *overlap_ul,
172 int mb_rows, int mb_cols,
173 union b_mode_info *bmi,
174 int b_row, int b_col)
175 {
176 MB_OVERLAP *mb_overlap;
177 int row, col, rel_row, rel_col;
178 int new_row, new_col;
179 int end_row, end_col;
180 int overlap_b_row, overlap_b_col;
181 int overlap_mb_row, overlap_mb_col;
182
183 /* mb subpixel position */
184 row = (4 * b_row) << 3; /* Q3 */
185 col = (4 * b_col) << 3; /* Q3 */
186
187 /* reverse compensate for motion */
188 new_row = row - bmi->mv.as_mv.row;
189 new_col = col - bmi->mv.as_mv.col;
190
191 if (new_row >= ((16*mb_rows) << 3) || new_col >= ((16*mb_cols) << 3))
192 {
193 /* the new block ended up outside the frame */
194 return;
195 }
196
197 if (new_row <= (-4 << 3) || new_col <= (-4 << 3))
198 {
199 /* outside the frame */
200 return;
201 }
202 /* overlapping block's position in blocks */
203 overlap_b_row = FLOOR(new_row / 4, 3) >> 3;
204 overlap_b_col = FLOOR(new_col / 4, 3) >> 3;
205
206 /* overlapping block's MB position in MBs
207 * operations are done in Q3
208 */
209 overlap_mb_row = FLOOR((overlap_b_row << 3) / 4, 3) >> 3;
210 overlap_mb_col = FLOOR((overlap_b_col << 3) / 4, 3) >> 3;
211
212 end_row = VPXMIN(mb_rows - overlap_mb_row, 2);
213 end_col = VPXMIN(mb_cols - overlap_mb_col, 2);
214
215 /* Don't calculate overlap for MBs we don't overlap */
216 /* Check if the new block row starts at the last block row of the MB */
217 if (abs(new_row - ((16*overlap_mb_row) << 3)) < ((3*4) << 3))
218 end_row = 1;
219 /* Check if the new block col starts at the last block col of the MB */
220 if (abs(new_col - ((16*overlap_mb_col) << 3)) < ((3*4) << 3))
221 end_col = 1;
222
223 /* find the MB(s) this block is overlapping */
224 for (rel_row = 0; rel_row < end_row; ++rel_row)
225 {
226 for (rel_col = 0; rel_col < end_col; ++rel_col)
227 {
228 if (overlap_mb_row + rel_row < 0 ||
229 overlap_mb_col + rel_col < 0)
230 continue;
231 mb_overlap = overlap_ul + (overlap_mb_row + rel_row) * mb_cols +
232 overlap_mb_col + rel_col;
233
234 calculate_overlaps_mb(mb_overlap->overlaps, bmi,
235 new_row, new_col,
236 overlap_mb_row + rel_row,
237 overlap_mb_col + rel_col,
238 overlap_b_row + rel_row,
239 overlap_b_col + rel_col);
240 }
241 }
242 }
243
244 /* Estimates a motion vector given the overlapping blocks' motion vectors.
245 * Filters out all overlapping blocks which do not refer to the correct
246 * reference frame type.
247 */
estimate_mv(const OVERLAP_NODE * overlaps,union b_mode_info * bmi)248 static void estimate_mv(const OVERLAP_NODE *overlaps, union b_mode_info *bmi)
249 {
250 int i;
251 int overlap_sum = 0;
252 int row_acc = 0;
253 int col_acc = 0;
254
255 bmi->mv.as_int = 0;
256 for (i=0; i < MAX_OVERLAPS; ++i)
257 {
258 if (overlaps[i].bmi == NULL)
259 break;
260 col_acc += overlaps[i].overlap * overlaps[i].bmi->mv.as_mv.col;
261 row_acc += overlaps[i].overlap * overlaps[i].bmi->mv.as_mv.row;
262 overlap_sum += overlaps[i].overlap;
263 }
264 if (overlap_sum > 0)
265 {
266 /* Q9 / Q6 = Q3 */
267 bmi->mv.as_mv.col = col_acc / overlap_sum;
268 bmi->mv.as_mv.row = row_acc / overlap_sum;
269 }
270 else
271 {
272 bmi->mv.as_mv.col = 0;
273 bmi->mv.as_mv.row = 0;
274 }
275 }
276
277 /* Estimates all motion vectors for a macroblock given the lists of
278 * overlaps for each block. Decides whether or not the MVs must be clamped.
279 */
estimate_mb_mvs(const B_OVERLAP * block_overlaps,MODE_INFO * mi,int mb_to_left_edge,int mb_to_right_edge,int mb_to_top_edge,int mb_to_bottom_edge)280 static void estimate_mb_mvs(const B_OVERLAP *block_overlaps,
281 MODE_INFO *mi,
282 int mb_to_left_edge,
283 int mb_to_right_edge,
284 int mb_to_top_edge,
285 int mb_to_bottom_edge)
286 {
287 int row, col;
288 int non_zero_count = 0;
289 MV * const filtered_mv = &(mi->mbmi.mv.as_mv);
290 union b_mode_info * const bmi = mi->bmi;
291 filtered_mv->col = 0;
292 filtered_mv->row = 0;
293 mi->mbmi.need_to_clamp_mvs = 0;
294 for (row = 0; row < 4; ++row)
295 {
296 int this_b_to_top_edge = mb_to_top_edge + ((row*4)<<3);
297 int this_b_to_bottom_edge = mb_to_bottom_edge - ((row*4)<<3);
298 for (col = 0; col < 4; ++col)
299 {
300 int i = row * 4 + col;
301 int this_b_to_left_edge = mb_to_left_edge + ((col*4)<<3);
302 int this_b_to_right_edge = mb_to_right_edge - ((col*4)<<3);
303 /* Estimate vectors for all blocks which are overlapped by this */
304 /* type. Interpolate/extrapolate the rest of the block's MVs */
305 estimate_mv(block_overlaps[i].overlaps, &(bmi[i]));
306 mi->mbmi.need_to_clamp_mvs |= vp8_check_mv_bounds(
307 &bmi[i].mv,
308 this_b_to_left_edge,
309 this_b_to_right_edge,
310 this_b_to_top_edge,
311 this_b_to_bottom_edge);
312 if (bmi[i].mv.as_int != 0)
313 {
314 ++non_zero_count;
315 filtered_mv->col += bmi[i].mv.as_mv.col;
316 filtered_mv->row += bmi[i].mv.as_mv.row;
317 }
318 }
319 }
320 if (non_zero_count > 0)
321 {
322 filtered_mv->col /= non_zero_count;
323 filtered_mv->row /= non_zero_count;
324 }
325 }
326
calc_prev_mb_overlaps(MB_OVERLAP * overlaps,MODE_INFO * prev_mi,int mb_row,int mb_col,int mb_rows,int mb_cols)327 static void calc_prev_mb_overlaps(MB_OVERLAP *overlaps, MODE_INFO *prev_mi,
328 int mb_row, int mb_col,
329 int mb_rows, int mb_cols)
330 {
331 int sub_row;
332 int sub_col;
333 for (sub_row = 0; sub_row < 4; ++sub_row)
334 {
335 for (sub_col = 0; sub_col < 4; ++sub_col)
336 {
337 vp8_calculate_overlaps(
338 overlaps, mb_rows, mb_cols,
339 &(prev_mi->bmi[sub_row * 4 + sub_col]),
340 4 * mb_row + sub_row,
341 4 * mb_col + sub_col);
342 }
343 }
344 }
345
346 /* Estimate all missing motion vectors. This function does the same as the one
347 * above, but has different input arguments. */
estimate_missing_mvs(MB_OVERLAP * overlaps,MODE_INFO * mi,MODE_INFO * prev_mi,int mb_rows,int mb_cols,unsigned int first_corrupt)348 static void estimate_missing_mvs(MB_OVERLAP *overlaps,
349 MODE_INFO *mi, MODE_INFO *prev_mi,
350 int mb_rows, int mb_cols,
351 unsigned int first_corrupt)
352 {
353 int mb_row, mb_col;
354 memset(overlaps, 0, sizeof(MB_OVERLAP) * mb_rows * mb_cols);
355 /* First calculate the overlaps for all blocks */
356 for (mb_row = 0; mb_row < mb_rows; ++mb_row)
357 {
358 for (mb_col = 0; mb_col < mb_cols; ++mb_col)
359 {
360 /* We're only able to use blocks referring to the last frame
361 * when extrapolating new vectors.
362 */
363 if (prev_mi->mbmi.ref_frame == LAST_FRAME)
364 {
365 calc_prev_mb_overlaps(overlaps, prev_mi,
366 mb_row, mb_col,
367 mb_rows, mb_cols);
368 }
369 ++prev_mi;
370 }
371 ++prev_mi;
372 }
373
374 mb_row = first_corrupt / mb_cols;
375 mb_col = first_corrupt - mb_row * mb_cols;
376 mi += mb_row*(mb_cols + 1) + mb_col;
377 /* Go through all macroblocks in the current image with missing MVs
378 * and calculate new MVs using the overlaps.
379 */
380 for (; mb_row < mb_rows; ++mb_row)
381 {
382 int mb_to_top_edge = -((mb_row * 16)) << 3;
383 int mb_to_bottom_edge = ((mb_rows - 1 - mb_row) * 16) << 3;
384 for (; mb_col < mb_cols; ++mb_col)
385 {
386 int mb_to_left_edge = -((mb_col * 16) << 3);
387 int mb_to_right_edge = ((mb_cols - 1 - mb_col) * 16) << 3;
388 const B_OVERLAP *block_overlaps =
389 overlaps[mb_row*mb_cols + mb_col].overlaps;
390 mi->mbmi.ref_frame = LAST_FRAME;
391 mi->mbmi.mode = SPLITMV;
392 mi->mbmi.uv_mode = DC_PRED;
393 mi->mbmi.partitioning = 3;
394 mi->mbmi.segment_id = 0;
395 estimate_mb_mvs(block_overlaps,
396 mi,
397 mb_to_left_edge,
398 mb_to_right_edge,
399 mb_to_top_edge,
400 mb_to_bottom_edge);
401 ++mi;
402 }
403 mb_col = 0;
404 ++mi;
405 }
406 }
407
vp8_estimate_missing_mvs(VP8D_COMP * pbi)408 void vp8_estimate_missing_mvs(VP8D_COMP *pbi)
409 {
410 VP8_COMMON * const pc = &pbi->common;
411 estimate_missing_mvs(pbi->overlaps,
412 pc->mi, pc->prev_mi,
413 pc->mb_rows, pc->mb_cols,
414 pbi->mvs_corrupt_from_mb);
415 }
416
assign_neighbor(EC_BLOCK * neighbor,MODE_INFO * mi,int block_idx)417 static void assign_neighbor(EC_BLOCK *neighbor, MODE_INFO *mi, int block_idx)
418 {
419 assert(mi->mbmi.ref_frame < MAX_REF_FRAMES);
420 neighbor->ref_frame = mi->mbmi.ref_frame;
421 neighbor->mv = mi->bmi[block_idx].mv.as_mv;
422 }
423
424 /* Finds the neighboring blocks of a macroblocks. In the general case
425 * 20 blocks are found. If a fewer number of blocks are found due to
426 * image boundaries, those positions in the EC_BLOCK array are left "empty".
427 * The neighbors are enumerated with the upper-left neighbor as the first
428 * element, the second element refers to the neighbor to right of the previous
429 * neighbor, and so on. The last element refers to the neighbor below the first
430 * neighbor.
431 */
find_neighboring_blocks(MODE_INFO * mi,EC_BLOCK * neighbors,int mb_row,int mb_col,int mb_rows,int mb_cols,int mi_stride)432 static void find_neighboring_blocks(MODE_INFO *mi,
433 EC_BLOCK *neighbors,
434 int mb_row, int mb_col,
435 int mb_rows, int mb_cols,
436 int mi_stride)
437 {
438 int i = 0;
439 int j;
440 if (mb_row > 0)
441 {
442 /* upper left */
443 if (mb_col > 0)
444 assign_neighbor(&neighbors[i], mi - mi_stride - 1, 15);
445 ++i;
446 /* above */
447 for (j = 12; j < 16; ++j, ++i)
448 assign_neighbor(&neighbors[i], mi - mi_stride, j);
449 }
450 else
451 i += 5;
452 if (mb_col < mb_cols - 1)
453 {
454 /* upper right */
455 if (mb_row > 0)
456 assign_neighbor(&neighbors[i], mi - mi_stride + 1, 12);
457 ++i;
458 /* right */
459 for (j = 0; j <= 12; j += 4, ++i)
460 assign_neighbor(&neighbors[i], mi + 1, j);
461 }
462 else
463 i += 5;
464 if (mb_row < mb_rows - 1)
465 {
466 /* lower right */
467 if (mb_col < mb_cols - 1)
468 assign_neighbor(&neighbors[i], mi + mi_stride + 1, 0);
469 ++i;
470 /* below */
471 for (j = 0; j < 4; ++j, ++i)
472 assign_neighbor(&neighbors[i], mi + mi_stride, j);
473 }
474 else
475 i += 5;
476 if (mb_col > 0)
477 {
478 /* lower left */
479 if (mb_row < mb_rows - 1)
480 assign_neighbor(&neighbors[i], mi + mi_stride - 1, 4);
481 ++i;
482 /* left */
483 for (j = 3; j < 16; j += 4, ++i)
484 {
485 assign_neighbor(&neighbors[i], mi - 1, j);
486 }
487 }
488 else
489 i += 5;
490 assert(i == 20);
491 }
492
493 /* Interpolates all motion vectors for a macroblock from the neighboring blocks'
494 * motion vectors.
495 */
interpolate_mvs(MACROBLOCKD * mb,EC_BLOCK * neighbors,MV_REFERENCE_FRAME dom_ref_frame)496 static void interpolate_mvs(MACROBLOCKD *mb,
497 EC_BLOCK *neighbors,
498 MV_REFERENCE_FRAME dom_ref_frame)
499 {
500 int row, col, i;
501 MODE_INFO * const mi = mb->mode_info_context;
502 /* Table with the position of the neighboring blocks relative the position
503 * of the upper left block of the current MB. Starting with the upper left
504 * neighbor and going to the right.
505 */
506 const EC_POS neigh_pos[NUM_NEIGHBORS] = {
507 {-1,-1}, {-1,0}, {-1,1}, {-1,2}, {-1,3},
508 {-1,4}, {0,4}, {1,4}, {2,4}, {3,4},
509 {4,4}, {4,3}, {4,2}, {4,1}, {4,0},
510 {4,-1}, {3,-1}, {2,-1}, {1,-1}, {0,-1}
511 };
512 mi->mbmi.need_to_clamp_mvs = 0;
513 for (row = 0; row < 4; ++row)
514 {
515 int mb_to_top_edge = mb->mb_to_top_edge + ((row*4)<<3);
516 int mb_to_bottom_edge = mb->mb_to_bottom_edge - ((row*4)<<3);
517 for (col = 0; col < 4; ++col)
518 {
519 int mb_to_left_edge = mb->mb_to_left_edge + ((col*4)<<3);
520 int mb_to_right_edge = mb->mb_to_right_edge - ((col*4)<<3);
521 int w_sum = 0;
522 int mv_row_sum = 0;
523 int mv_col_sum = 0;
524 int_mv * const mv = &(mi->bmi[row*4 + col].mv);
525 mv->as_int = 0;
526 for (i = 0; i < NUM_NEIGHBORS; ++i)
527 {
528 /* Calculate the weighted sum of neighboring MVs referring
529 * to the dominant frame type.
530 */
531 const int w = weights_q7[abs(row - neigh_pos[i].row)]
532 [abs(col - neigh_pos[i].col)];
533 if (neighbors[i].ref_frame != dom_ref_frame)
534 continue;
535 w_sum += w;
536 /* Q7 * Q3 = Q10 */
537 mv_row_sum += w*neighbors[i].mv.row;
538 mv_col_sum += w*neighbors[i].mv.col;
539 }
540 if (w_sum > 0)
541 {
542 /* Avoid division by zero.
543 * Normalize with the sum of the coefficients
544 * Q3 = Q10 / Q7
545 */
546 mv->as_mv.row = mv_row_sum / w_sum;
547 mv->as_mv.col = mv_col_sum / w_sum;
548 mi->mbmi.need_to_clamp_mvs |= vp8_check_mv_bounds(
549 mv,
550 mb_to_left_edge,
551 mb_to_right_edge,
552 mb_to_top_edge,
553 mb_to_bottom_edge);
554 }
555 }
556 }
557 }
558
vp8_interpolate_motion(MACROBLOCKD * mb,int mb_row,int mb_col,int mb_rows,int mb_cols,int mi_stride)559 void vp8_interpolate_motion(MACROBLOCKD *mb,
560 int mb_row, int mb_col,
561 int mb_rows, int mb_cols,
562 int mi_stride)
563 {
564 /* Find relevant neighboring blocks */
565 EC_BLOCK neighbors[NUM_NEIGHBORS];
566 int i;
567 /* Initialize the array. MAX_REF_FRAMES is interpreted as "doesn't exist" */
568 for (i = 0; i < NUM_NEIGHBORS; ++i)
569 {
570 neighbors[i].ref_frame = MAX_REF_FRAMES;
571 neighbors[i].mv.row = neighbors[i].mv.col = 0;
572 }
573 find_neighboring_blocks(mb->mode_info_context,
574 neighbors,
575 mb_row, mb_col,
576 mb_rows, mb_cols,
577 mb->mode_info_stride);
578 /* Interpolate MVs for the missing blocks from the surrounding
579 * blocks which refer to the last frame. */
580 interpolate_mvs(mb, neighbors, LAST_FRAME);
581
582 mb->mode_info_context->mbmi.ref_frame = LAST_FRAME;
583 mb->mode_info_context->mbmi.mode = SPLITMV;
584 mb->mode_info_context->mbmi.uv_mode = DC_PRED;
585 mb->mode_info_context->mbmi.partitioning = 3;
586 mb->mode_info_context->mbmi.segment_id = 0;
587 }
588
vp8_conceal_corrupt_mb(MACROBLOCKD * xd)589 void vp8_conceal_corrupt_mb(MACROBLOCKD *xd)
590 {
591 /* This macroblock has corrupt residual, use the motion compensated
592 image (predictor) for concealment */
593
594 /* The build predictor functions now output directly into the dst buffer,
595 * so the copies are no longer necessary */
596
597 }
598