The Tor Browser / file comparison

comparison: media/libvpx/vp8/decoder/decodemv.c

media/libvpx/vp8/decoder/decodemv.c

changeset 0
6474c204b198
equal deleted inserted replaced
-1:000000000000 0:5e5be42966cf
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 "treereader.h"
13 #include "vp8/common/entropymv.h"
14 #include "vp8/common/entropymode.h"
15 #include "onyxd_int.h"
16 #include "vp8/common/findnearmv.h"
17
18 #if CONFIG_DEBUG
19 #include <assert.h>
20 #endif
21 static B_PREDICTION_MODE read_bmode(vp8_reader *bc, const vp8_prob *p)
22 {
23 const int i = vp8_treed_read(bc, vp8_bmode_tree, p);
24
25 return (B_PREDICTION_MODE)i;
26 }
27
28 static MB_PREDICTION_MODE read_ymode(vp8_reader *bc, const vp8_prob *p)
29 {
30 const int i = vp8_treed_read(bc, vp8_ymode_tree, p);
31
32 return (MB_PREDICTION_MODE)i;
33 }
34
35 static MB_PREDICTION_MODE read_kf_ymode(vp8_reader *bc, const vp8_prob *p)
36 {
37 const int i = vp8_treed_read(bc, vp8_kf_ymode_tree, p);
38
39 return (MB_PREDICTION_MODE)i;
40 }
41
42 static MB_PREDICTION_MODE read_uv_mode(vp8_reader *bc, const vp8_prob *p)
43 {
44 const int i = vp8_treed_read(bc, vp8_uv_mode_tree, p);
45
46 return (MB_PREDICTION_MODE)i;
47 }
48
49 static void read_kf_modes(VP8D_COMP *pbi, MODE_INFO *mi)
50 {
51 vp8_reader *const bc = & pbi->mbc[8];
52 const int mis = pbi->common.mode_info_stride;
53
54 mi->mbmi.ref_frame = INTRA_FRAME;
55 mi->mbmi.mode = read_kf_ymode(bc, vp8_kf_ymode_prob);
56
57 if (mi->mbmi.mode == B_PRED)
58 {
59 int i = 0;
60 mi->mbmi.is_4x4 = 1;
61
62 do
63 {
64 const B_PREDICTION_MODE A = above_block_mode(mi, i, mis);
65 const B_PREDICTION_MODE L = left_block_mode(mi, i);
66
67 mi->bmi[i].as_mode =
68 read_bmode(bc, vp8_kf_bmode_prob [A] [L]);
69 }
70 while (++i < 16);
71 }
72
73 mi->mbmi.uv_mode = read_uv_mode(bc, vp8_kf_uv_mode_prob);
74 }
75
76 static int read_mvcomponent(vp8_reader *r, const MV_CONTEXT *mvc)
77 {
78 const vp8_prob *const p = (const vp8_prob *) mvc;
79 int x = 0;
80
81 if (vp8_read(r, p [mvpis_short])) /* Large */
82 {
83 int i = 0;
84
85 do
86 {
87 x += vp8_read(r, p [MVPbits + i]) << i;
88 }
89 while (++i < 3);
90
91 i = mvlong_width - 1; /* Skip bit 3, which is sometimes implicit */
92
93 do
94 {
95 x += vp8_read(r, p [MVPbits + i]) << i;
96 }
97 while (--i > 3);
98
99 if (!(x & 0xFFF0) || vp8_read(r, p [MVPbits + 3]))
100 x += 8;
101 }
102 else /* small */
103 x = vp8_treed_read(r, vp8_small_mvtree, p + MVPshort);
104
105 if (x && vp8_read(r, p [MVPsign]))
106 x = -x;
107
108 return x;
109 }
110
111 static void read_mv(vp8_reader *r, MV *mv, const MV_CONTEXT *mvc)
112 {
113 mv->row = (short)(read_mvcomponent(r, mvc) * 2);
114 mv->col = (short)(read_mvcomponent(r, ++mvc) * 2);
115 }
116
117
118 static void read_mvcontexts(vp8_reader *bc, MV_CONTEXT *mvc)
119 {
120 int i = 0;
121
122 do
123 {
124 const vp8_prob *up = vp8_mv_update_probs[i].prob;
125 vp8_prob *p = (vp8_prob *)(mvc + i);
126 vp8_prob *const pstop = p + MVPcount;
127
128 do
129 {
130 if (vp8_read(bc, *up++))
131 {
132 const vp8_prob x = (vp8_prob)vp8_read_literal(bc, 7);
133
134 *p = x ? x << 1 : 1;
135 }
136 }
137 while (++p < pstop);
138 }
139 while (++i < 2);
140 }
141
142 static const unsigned char mbsplit_fill_count[4] = {8, 8, 4, 1};
143 static const unsigned char mbsplit_fill_offset[4][16] = {
144 { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15},
145 { 0, 1, 4, 5, 8, 9, 12, 13, 2, 3, 6, 7, 10, 11, 14, 15},
146 { 0, 1, 4, 5, 2, 3, 6, 7, 8, 9, 12, 13, 10, 11, 14, 15},
147 { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15}
148 };
149
150
151 static void mb_mode_mv_init(VP8D_COMP *pbi)
152 {
153 vp8_reader *const bc = & pbi->mbc[8];
154 MV_CONTEXT *const mvc = pbi->common.fc.mvc;
155
156 #if CONFIG_ERROR_CONCEALMENT
157 /* Default is that no macroblock is corrupt, therefore we initialize
158 * mvs_corrupt_from_mb to something very big, which we can be sure is
159 * outside the frame. */
160 pbi->mvs_corrupt_from_mb = UINT_MAX;
161 #endif
162 /* Read the mb_no_coeff_skip flag */
163 pbi->common.mb_no_coeff_skip = (int)vp8_read_bit(bc);
164
165 pbi->prob_skip_false = 0;
166 if (pbi->common.mb_no_coeff_skip)
167 pbi->prob_skip_false = (vp8_prob)vp8_read_literal(bc, 8);
168
169 if(pbi->common.frame_type != KEY_FRAME)
170 {
171 pbi->prob_intra = (vp8_prob)vp8_read_literal(bc, 8);
172 pbi->prob_last = (vp8_prob)vp8_read_literal(bc, 8);
173 pbi->prob_gf = (vp8_prob)vp8_read_literal(bc, 8);
174
175 if (vp8_read_bit(bc))
176 {
177 int i = 0;
178
179 do
180 {
181 pbi->common.fc.ymode_prob[i] =
182 (vp8_prob) vp8_read_literal(bc, 8);
183 }
184 while (++i < 4);
185 }
186
187 if (vp8_read_bit(bc))
188 {
189 int i = 0;
190
191 do
192 {
193 pbi->common.fc.uv_mode_prob[i] =
194 (vp8_prob) vp8_read_literal(bc, 8);
195 }
196 while (++i < 3);
197 }
198
199 read_mvcontexts(bc, mvc);
200 }
201 }
202
203 const vp8_prob vp8_sub_mv_ref_prob3 [8][VP8_SUBMVREFS-1] =
204 {
205 { 147, 136, 18 }, /* SUBMVREF_NORMAL */
206 { 223, 1 , 34 }, /* SUBMVREF_LEFT_ABOVE_SAME */
207 { 106, 145, 1 }, /* SUBMVREF_LEFT_ZED */
208 { 208, 1 , 1 }, /* SUBMVREF_LEFT_ABOVE_ZED */
209 { 179, 121, 1 }, /* SUBMVREF_ABOVE_ZED */
210 { 223, 1 , 34 }, /* SUBMVREF_LEFT_ABOVE_SAME */
211 { 179, 121, 1 }, /* SUBMVREF_ABOVE_ZED */
212 { 208, 1 , 1 } /* SUBMVREF_LEFT_ABOVE_ZED */
213 };
214
215 static
216 const vp8_prob * get_sub_mv_ref_prob(const int left, const int above)
217 {
218 int lez = (left == 0);
219 int aez = (above == 0);
220 int lea = (left == above);
221 const vp8_prob * prob;
222
223 prob = vp8_sub_mv_ref_prob3[(aez << 2) |
224 (lez << 1) |
225 (lea)];
226
227 return prob;
228 }
229
230 static void decode_split_mv(vp8_reader *const bc, MODE_INFO *mi,
231 const MODE_INFO *left_mb, const MODE_INFO *above_mb,
232 MB_MODE_INFO *mbmi, int_mv best_mv,
233 MV_CONTEXT *const mvc, int mb_to_left_edge,
234 int mb_to_right_edge, int mb_to_top_edge,
235 int mb_to_bottom_edge)
236 {
237 int s; /* split configuration (16x8, 8x16, 8x8, 4x4) */
238 int num_p; /* number of partitions in the split configuration
239 (see vp8_mbsplit_count) */
240 int j = 0;
241
242 s = 3;
243 num_p = 16;
244 if( vp8_read(bc, 110) )
245 {
246 s = 2;
247 num_p = 4;
248 if( vp8_read(bc, 111) )
249 {
250 s = vp8_read(bc, 150);
251 num_p = 2;
252 }
253 }
254
255 do /* for each subset j */
256 {
257 int_mv leftmv, abovemv;
258 int_mv blockmv;
259 int k; /* first block in subset j */
260
261 const vp8_prob *prob;
262 k = vp8_mbsplit_offset[s][j];
263
264 if (!(k & 3))
265 {
266 /* On L edge, get from MB to left of us */
267 if(left_mb->mbmi.mode != SPLITMV)
268 leftmv.as_int = left_mb->mbmi.mv.as_int;
269 else
270 leftmv.as_int = (left_mb->bmi + k + 4 - 1)->mv.as_int;
271 }
272 else
273 leftmv.as_int = (mi->bmi + k - 1)->mv.as_int;
274
275 if (!(k >> 2))
276 {
277 /* On top edge, get from MB above us */
278 if(above_mb->mbmi.mode != SPLITMV)
279 abovemv.as_int = above_mb->mbmi.mv.as_int;
280 else
281 abovemv.as_int = (above_mb->bmi + k + 16 - 4)->mv.as_int;
282 }
283 else
284 abovemv.as_int = (mi->bmi + k - 4)->mv.as_int;
285
286 prob = get_sub_mv_ref_prob(leftmv.as_int, abovemv.as_int);
287
288 if( vp8_read(bc, prob[0]) )
289 {
290 if( vp8_read(bc, prob[1]) )
291 {
292 blockmv.as_int = 0;
293 if( vp8_read(bc, prob[2]) )
294 {
295 blockmv.as_mv.row = read_mvcomponent(bc, &mvc[0]) * 2;
296 blockmv.as_mv.row += best_mv.as_mv.row;
297 blockmv.as_mv.col = read_mvcomponent(bc, &mvc[1]) * 2;
298 blockmv.as_mv.col += best_mv.as_mv.col;
299 }
300 }
301 else
302 {
303 blockmv.as_int = abovemv.as_int;
304 }
305 }
306 else
307 {
308 blockmv.as_int = leftmv.as_int;
309 }
310
311 mbmi->need_to_clamp_mvs |= vp8_check_mv_bounds(&blockmv,
312 mb_to_left_edge,
313 mb_to_right_edge,
314 mb_to_top_edge,
315 mb_to_bottom_edge);
316
317 {
318 /* Fill (uniform) modes, mvs of jth subset.
319 Must do it here because ensuing subsets can
320 refer back to us via "left" or "above". */
321 const unsigned char *fill_offset;
322 unsigned int fill_count = mbsplit_fill_count[s];
323
324 fill_offset = &mbsplit_fill_offset[s]
325 [(unsigned char)j * mbsplit_fill_count[s]];
326
327 do {
328 mi->bmi[ *fill_offset].mv.as_int = blockmv.as_int;
329 fill_offset++;
330 }while (--fill_count);
331 }
332
333 }
334 while (++j < num_p);
335
336 mbmi->partitioning = s;
337 }
338
339 static void read_mb_modes_mv(VP8D_COMP *pbi, MODE_INFO *mi, MB_MODE_INFO *mbmi)
340 {
341 vp8_reader *const bc = & pbi->mbc[8];
342 mbmi->ref_frame = (MV_REFERENCE_FRAME) vp8_read(bc, pbi->prob_intra);
343 if (mbmi->ref_frame) /* inter MB */
344 {
345 enum {CNT_INTRA, CNT_NEAREST, CNT_NEAR, CNT_SPLITMV};
346 int cnt[4];
347 int *cntx = cnt;
348 int_mv near_mvs[4];
349 int_mv *nmv = near_mvs;
350 const int mis = pbi->mb.mode_info_stride;
351 const MODE_INFO *above = mi - mis;
352 const MODE_INFO *left = mi - 1;
353 const MODE_INFO *aboveleft = above - 1;
354 int *ref_frame_sign_bias = pbi->common.ref_frame_sign_bias;
355
356 mbmi->need_to_clamp_mvs = 0;
357
358 if (vp8_read(bc, pbi->prob_last))
359 {
360 mbmi->ref_frame =
361 (MV_REFERENCE_FRAME)((int)(2 + vp8_read(bc, pbi->prob_gf)));
362 }
363
364 /* Zero accumulators */
365 nmv[0].as_int = nmv[1].as_int = nmv[2].as_int = 0;
366 cnt[0] = cnt[1] = cnt[2] = cnt[3] = 0;
367
368 /* Process above */
369 if (above->mbmi.ref_frame != INTRA_FRAME)
370 {
371 if (above->mbmi.mv.as_int)
372 {
373 (++nmv)->as_int = above->mbmi.mv.as_int;
374 mv_bias(ref_frame_sign_bias[above->mbmi.ref_frame],
375 mbmi->ref_frame, nmv, ref_frame_sign_bias);
376 ++cntx;
377 }
378
379 *cntx += 2;
380 }
381
382 /* Process left */
383 if (left->mbmi.ref_frame != INTRA_FRAME)
384 {
385 if (left->mbmi.mv.as_int)
386 {
387 int_mv this_mv;
388
389 this_mv.as_int = left->mbmi.mv.as_int;
390 mv_bias(ref_frame_sign_bias[left->mbmi.ref_frame],
391 mbmi->ref_frame, &this_mv, ref_frame_sign_bias);
392
393 if (this_mv.as_int != nmv->as_int)
394 {
395 (++nmv)->as_int = this_mv.as_int;
396 ++cntx;
397 }
398
399 *cntx += 2;
400 }
401 else
402 cnt[CNT_INTRA] += 2;
403 }
404
405 /* Process above left */
406 if (aboveleft->mbmi.ref_frame != INTRA_FRAME)
407 {
408 if (aboveleft->mbmi.mv.as_int)
409 {
410 int_mv this_mv;
411
412 this_mv.as_int = aboveleft->mbmi.mv.as_int;
413 mv_bias(ref_frame_sign_bias[aboveleft->mbmi.ref_frame],
414 mbmi->ref_frame, &this_mv, ref_frame_sign_bias);
415
416 if (this_mv.as_int != nmv->as_int)
417 {
418 (++nmv)->as_int = this_mv.as_int;
419 ++cntx;
420 }
421
422 *cntx += 1;
423 }
424 else
425 cnt[CNT_INTRA] += 1;
426 }
427
428 if( vp8_read(bc, vp8_mode_contexts [cnt[CNT_INTRA]] [0]) )
429 {
430
431 /* If we have three distinct MV's ... */
432 /* See if above-left MV can be merged with NEAREST */
433 cnt[CNT_NEAREST] += ( (cnt[CNT_SPLITMV] > 0) &
434 (nmv->as_int == near_mvs[CNT_NEAREST].as_int));
435
436 /* Swap near and nearest if necessary */
437 if (cnt[CNT_NEAR] > cnt[CNT_NEAREST])
438 {
439 int tmp;
440 tmp = cnt[CNT_NEAREST];
441 cnt[CNT_NEAREST] = cnt[CNT_NEAR];
442 cnt[CNT_NEAR] = tmp;
443 tmp = near_mvs[CNT_NEAREST].as_int;
444 near_mvs[CNT_NEAREST].as_int = near_mvs[CNT_NEAR].as_int;
445 near_mvs[CNT_NEAR].as_int = tmp;
446 }
447
448 if( vp8_read(bc, vp8_mode_contexts [cnt[CNT_NEAREST]] [1]) )
449 {
450
451 if( vp8_read(bc, vp8_mode_contexts [cnt[CNT_NEAR]] [2]) )
452 {
453 int mb_to_top_edge;
454 int mb_to_bottom_edge;
455 int mb_to_left_edge;
456 int mb_to_right_edge;
457 MV_CONTEXT *const mvc = pbi->common.fc.mvc;
458 int near_index;
459
460 mb_to_top_edge = pbi->mb.mb_to_top_edge;
461 mb_to_bottom_edge = pbi->mb.mb_to_bottom_edge;
462 mb_to_top_edge -= LEFT_TOP_MARGIN;
463 mb_to_bottom_edge += RIGHT_BOTTOM_MARGIN;
464 mb_to_right_edge = pbi->mb.mb_to_right_edge;
465 mb_to_right_edge += RIGHT_BOTTOM_MARGIN;
466 mb_to_left_edge = pbi->mb.mb_to_left_edge;
467 mb_to_left_edge -= LEFT_TOP_MARGIN;
468
469 /* Use near_mvs[0] to store the "best" MV */
470 near_index = CNT_INTRA +
471 (cnt[CNT_NEAREST] >= cnt[CNT_INTRA]);
472
473 vp8_clamp_mv2(&near_mvs[near_index], &pbi->mb);
474
475 cnt[CNT_SPLITMV] = ((above->mbmi.mode == SPLITMV)
476 + (left->mbmi.mode == SPLITMV)) * 2
477 + (aboveleft->mbmi.mode == SPLITMV);
478
479 if( vp8_read(bc, vp8_mode_contexts [cnt[CNT_SPLITMV]] [3]) )
480 {
481 decode_split_mv(bc, mi, left, above,
482 mbmi,
483 near_mvs[near_index],
484 mvc, mb_to_left_edge,
485 mb_to_right_edge,
486 mb_to_top_edge,
487 mb_to_bottom_edge);
488 mbmi->mv.as_int = mi->bmi[15].mv.as_int;
489 mbmi->mode = SPLITMV;
490 mbmi->is_4x4 = 1;
491 }
492 else
493 {
494 int_mv *const mbmi_mv = & mbmi->mv;
495 read_mv(bc, &mbmi_mv->as_mv, (const MV_CONTEXT *) mvc);
496 mbmi_mv->as_mv.row += near_mvs[near_index].as_mv.row;
497 mbmi_mv->as_mv.col += near_mvs[near_index].as_mv.col;
498
499 /* Don't need to check this on NEARMV and NEARESTMV
500 * modes since those modes clamp the MV. The NEWMV mode
501 * does not, so signal to the prediction stage whether
502 * special handling may be required.
503 */
504 mbmi->need_to_clamp_mvs =
505 vp8_check_mv_bounds(mbmi_mv, mb_to_left_edge,
506 mb_to_right_edge,
507 mb_to_top_edge,
508 mb_to_bottom_edge);
509 mbmi->mode = NEWMV;
510 }
511 }
512 else
513 {
514 mbmi->mode = NEARMV;
515 mbmi->mv.as_int = near_mvs[CNT_NEAR].as_int;
516 vp8_clamp_mv2(&mbmi->mv, &pbi->mb);
517 }
518 }
519 else
520 {
521 mbmi->mode = NEARESTMV;
522 mbmi->mv.as_int = near_mvs[CNT_NEAREST].as_int;
523 vp8_clamp_mv2(&mbmi->mv, &pbi->mb);
524 }
525 }
526 else
527 {
528 mbmi->mode = ZEROMV;
529 mbmi->mv.as_int = 0;
530 }
531
532 #if CONFIG_ERROR_CONCEALMENT
533 if(pbi->ec_enabled && (mbmi->mode != SPLITMV))
534 {
535 mi->bmi[ 0].mv.as_int =
536 mi->bmi[ 1].mv.as_int =
537 mi->bmi[ 2].mv.as_int =
538 mi->bmi[ 3].mv.as_int =
539 mi->bmi[ 4].mv.as_int =
540 mi->bmi[ 5].mv.as_int =
541 mi->bmi[ 6].mv.as_int =
542 mi->bmi[ 7].mv.as_int =
543 mi->bmi[ 8].mv.as_int =
544 mi->bmi[ 9].mv.as_int =
545 mi->bmi[10].mv.as_int =
546 mi->bmi[11].mv.as_int =
547 mi->bmi[12].mv.as_int =
548 mi->bmi[13].mv.as_int =
549 mi->bmi[14].mv.as_int =
550 mi->bmi[15].mv.as_int = mbmi->mv.as_int;
551 }
552 #endif
553 }
554 else
555 {
556 /* required for left and above block mv */
557 mbmi->mv.as_int = 0;
558
559 /* MB is intra coded */
560 if ((mbmi->mode = read_ymode(bc, pbi->common.fc.ymode_prob)) == B_PRED)
561 {
562 int j = 0;
563 mbmi->is_4x4 = 1;
564 do
565 {
566 mi->bmi[j].as_mode = read_bmode(bc, pbi->common.fc.bmode_prob);
567 }
568 while (++j < 16);
569 }
570
571 mbmi->uv_mode = read_uv_mode(bc, pbi->common.fc.uv_mode_prob);
572 }
573
574 }
575
576 static void read_mb_features(vp8_reader *r, MB_MODE_INFO *mi, MACROBLOCKD *x)
577 {
578 /* Is segmentation enabled */
579 if (x->segmentation_enabled && x->update_mb_segmentation_map)
580 {
581 /* If so then read the segment id. */
582 if (vp8_read(r, x->mb_segment_tree_probs[0]))
583 mi->segment_id =
584 (unsigned char)(2 + vp8_read(r, x->mb_segment_tree_probs[2]));
585 else
586 mi->segment_id =
587 (unsigned char)(vp8_read(r, x->mb_segment_tree_probs[1]));
588 }
589 }
590
591 static void decode_mb_mode_mvs(VP8D_COMP *pbi, MODE_INFO *mi,
592 MB_MODE_INFO *mbmi)
593 {
594 /* Read the Macroblock segmentation map if it is being updated explicitly
595 * this frame (reset to 0 above by default)
596 * By default on a key frame reset all MBs to segment 0
597 */
598 if (pbi->mb.update_mb_segmentation_map)
599 read_mb_features(&pbi->mbc[8], &mi->mbmi, &pbi->mb);
600 else if(pbi->common.frame_type == KEY_FRAME)
601 mi->mbmi.segment_id = 0;
602
603 /* Read the macroblock coeff skip flag if this feature is in use,
604 * else default to 0 */
605 if (pbi->common.mb_no_coeff_skip)
606 mi->mbmi.mb_skip_coeff = vp8_read(&pbi->mbc[8], pbi->prob_skip_false);
607 else
608 mi->mbmi.mb_skip_coeff = 0;
609
610 mi->mbmi.is_4x4 = 0;
611 if(pbi->common.frame_type == KEY_FRAME)
612 read_kf_modes(pbi, mi);
613 else
614 read_mb_modes_mv(pbi, mi, &mi->mbmi);
615
616 }
617
618 void vp8_decode_mode_mvs(VP8D_COMP *pbi)
619 {
620 MODE_INFO *mi = pbi->common.mi;
621 int mb_row = -1;
622 int mb_to_right_edge_start;
623
624 mb_mode_mv_init(pbi);
625
626 pbi->mb.mb_to_top_edge = 0;
627 pbi->mb.mb_to_bottom_edge = ((pbi->common.mb_rows - 1) * 16) << 3;
628 mb_to_right_edge_start = ((pbi->common.mb_cols - 1) * 16) << 3;
629
630 while (++mb_row < pbi->common.mb_rows)
631 {
632 int mb_col = -1;
633
634 pbi->mb.mb_to_left_edge = 0;
635 pbi->mb.mb_to_right_edge = mb_to_right_edge_start;
636
637 while (++mb_col < pbi->common.mb_cols)
638 {
639 #if CONFIG_ERROR_CONCEALMENT
640 int mb_num = mb_row * pbi->common.mb_cols + mb_col;
641 #endif
642
643 decode_mb_mode_mvs(pbi, mi, &mi->mbmi);
644
645 #if CONFIG_ERROR_CONCEALMENT
646 /* look for corruption. set mvs_corrupt_from_mb to the current
647 * mb_num if the frame is corrupt from this macroblock. */
648 if (vp8dx_bool_error(&pbi->mbc[8]) && mb_num <
649 (int)pbi->mvs_corrupt_from_mb)
650 {
651 pbi->mvs_corrupt_from_mb = mb_num;
652 /* no need to continue since the partition is corrupt from
653 * here on.
654 */
655 return;
656 }
657 #endif
658
659 pbi->mb.mb_to_left_edge -= (16 << 3);
660 pbi->mb.mb_to_right_edge -= (16 << 3);
661 mi++; /* next macroblock */
662 }
663 pbi->mb.mb_to_top_edge -= (16 << 3);
664 pbi->mb.mb_to_bottom_edge -= (16 << 3);
665
666 mi++; /* skip left predictor each row */
667 }
668 }

Mercurial Repository: The Tor Browser

Europalab SCM Repository Server

mercurial