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 "vpx_ports/config.h"
13 #include "vp8/common/recon.h"
14 #include "vp8/common/reconintra.h"
15 #include "vpx_mem/vpx_mem.h"
16 #include "onyxd_int.h"
17
18 /* For skip_recon_mb(), add vp8_build_intra_predictors_mby_s(MACROBLOCKD *x) and
19 * vp8_build_intra_predictors_mbuv_s(MACROBLOCKD *x).
20 */
21
vp8mt_build_intra_predictors_mby(VP8D_COMP * pbi,MACROBLOCKD * x,int mb_row,int mb_col)22 void vp8mt_build_intra_predictors_mby(VP8D_COMP *pbi, MACROBLOCKD *x, int mb_row, int mb_col)
23 {
24 unsigned char *yabove_row; /* = x->dst.y_buffer - x->dst.y_stride; */
25 unsigned char *yleft_col;
26 unsigned char yleft_buf[16];
27 unsigned char ytop_left; /* = yabove_row[-1]; */
28 unsigned char *ypred_ptr = x->predictor;
29 int r, c, i;
30
31 if (pbi->common.filter_level)
32 {
33 yabove_row = pbi->mt_yabove_row[mb_row] + mb_col*16 +32;
34 yleft_col = pbi->mt_yleft_col[mb_row];
35 } else
36 {
37 yabove_row = x->dst.y_buffer - x->dst.y_stride;
38
39 for (i = 0; i < 16; i++)
40 yleft_buf[i] = x->dst.y_buffer [i* x->dst.y_stride -1];
41 yleft_col = yleft_buf;
42 }
43
44 ytop_left = yabove_row[-1];
45
46 /* for Y */
47 switch (x->mode_info_context->mbmi.mode)
48 {
49 case DC_PRED:
50 {
51 int expected_dc;
52 int i;
53 int shift;
54 int average = 0;
55
56
57 if (x->up_available || x->left_available)
58 {
59 if (x->up_available)
60 {
61 for (i = 0; i < 16; i++)
62 {
63 average += yabove_row[i];
64 }
65 }
66
67 if (x->left_available)
68 {
69
70 for (i = 0; i < 16; i++)
71 {
72 average += yleft_col[i];
73 }
74
75 }
76
77
78
79 shift = 3 + x->up_available + x->left_available;
80 expected_dc = (average + (1 << (shift - 1))) >> shift;
81 }
82 else
83 {
84 expected_dc = 128;
85 }
86
87 vpx_memset(ypred_ptr, expected_dc, 256);
88 }
89 break;
90 case V_PRED:
91 {
92
93 for (r = 0; r < 16; r++)
94 {
95
96 ((int *)ypred_ptr)[0] = ((int *)yabove_row)[0];
97 ((int *)ypred_ptr)[1] = ((int *)yabove_row)[1];
98 ((int *)ypred_ptr)[2] = ((int *)yabove_row)[2];
99 ((int *)ypred_ptr)[3] = ((int *)yabove_row)[3];
100 ypred_ptr += 16;
101 }
102 }
103 break;
104 case H_PRED:
105 {
106
107 for (r = 0; r < 16; r++)
108 {
109
110 vpx_memset(ypred_ptr, yleft_col[r], 16);
111 ypred_ptr += 16;
112 }
113
114 }
115 break;
116 case TM_PRED:
117 {
118
119 for (r = 0; r < 16; r++)
120 {
121 for (c = 0; c < 16; c++)
122 {
123 int pred = yleft_col[r] + yabove_row[ c] - ytop_left;
124
125 if (pred < 0)
126 pred = 0;
127
128 if (pred > 255)
129 pred = 255;
130
131 ypred_ptr[c] = pred;
132 }
133
134 ypred_ptr += 16;
135 }
136
137 }
138 break;
139 case B_PRED:
140 case NEARESTMV:
141 case NEARMV:
142 case ZEROMV:
143 case NEWMV:
144 case SPLITMV:
145 case MB_MODE_COUNT:
146 break;
147 }
148 }
149
vp8mt_build_intra_predictors_mby_s(VP8D_COMP * pbi,MACROBLOCKD * x,int mb_row,int mb_col)150 void vp8mt_build_intra_predictors_mby_s(VP8D_COMP *pbi, MACROBLOCKD *x, int mb_row, int mb_col)
151 {
152 unsigned char *yabove_row; /* = x->dst.y_buffer - x->dst.y_stride; */
153 unsigned char *yleft_col;
154 unsigned char yleft_buf[16];
155 unsigned char ytop_left; /* = yabove_row[-1]; */
156 unsigned char *ypred_ptr = x->predictor;
157 int r, c, i;
158
159 int y_stride = x->dst.y_stride;
160 ypred_ptr = x->dst.y_buffer; /*x->predictor;*/
161
162 if (pbi->common.filter_level)
163 {
164 yabove_row = pbi->mt_yabove_row[mb_row] + mb_col*16 +32;
165 yleft_col = pbi->mt_yleft_col[mb_row];
166 } else
167 {
168 yabove_row = x->dst.y_buffer - x->dst.y_stride;
169
170 for (i = 0; i < 16; i++)
171 yleft_buf[i] = x->dst.y_buffer [i* x->dst.y_stride -1];
172 yleft_col = yleft_buf;
173 }
174
175 ytop_left = yabove_row[-1];
176
177 /* for Y */
178 switch (x->mode_info_context->mbmi.mode)
179 {
180 case DC_PRED:
181 {
182 int expected_dc;
183 int i;
184 int shift;
185 int average = 0;
186
187
188 if (x->up_available || x->left_available)
189 {
190 if (x->up_available)
191 {
192 for (i = 0; i < 16; i++)
193 {
194 average += yabove_row[i];
195 }
196 }
197
198 if (x->left_available)
199 {
200
201 for (i = 0; i < 16; i++)
202 {
203 average += yleft_col[i];
204 }
205
206 }
207
208
209
210 shift = 3 + x->up_available + x->left_available;
211 expected_dc = (average + (1 << (shift - 1))) >> shift;
212 }
213 else
214 {
215 expected_dc = 128;
216 }
217
218 /*vpx_memset(ypred_ptr, expected_dc, 256);*/
219 for (r = 0; r < 16; r++)
220 {
221 vpx_memset(ypred_ptr, expected_dc, 16);
222 ypred_ptr += y_stride; /*16;*/
223 }
224 }
225 break;
226 case V_PRED:
227 {
228
229 for (r = 0; r < 16; r++)
230 {
231
232 ((int *)ypred_ptr)[0] = ((int *)yabove_row)[0];
233 ((int *)ypred_ptr)[1] = ((int *)yabove_row)[1];
234 ((int *)ypred_ptr)[2] = ((int *)yabove_row)[2];
235 ((int *)ypred_ptr)[3] = ((int *)yabove_row)[3];
236 ypred_ptr += y_stride; /*16;*/
237 }
238 }
239 break;
240 case H_PRED:
241 {
242
243 for (r = 0; r < 16; r++)
244 {
245
246 vpx_memset(ypred_ptr, yleft_col[r], 16);
247 ypred_ptr += y_stride; /*16;*/
248 }
249
250 }
251 break;
252 case TM_PRED:
253 {
254
255 for (r = 0; r < 16; r++)
256 {
257 for (c = 0; c < 16; c++)
258 {
259 int pred = yleft_col[r] + yabove_row[ c] - ytop_left;
260
261 if (pred < 0)
262 pred = 0;
263
264 if (pred > 255)
265 pred = 255;
266
267 ypred_ptr[c] = pred;
268 }
269
270 ypred_ptr += y_stride; /*16;*/
271 }
272
273 }
274 break;
275 case B_PRED:
276 case NEARESTMV:
277 case NEARMV:
278 case ZEROMV:
279 case NEWMV:
280 case SPLITMV:
281 case MB_MODE_COUNT:
282 break;
283 }
284 }
285
vp8mt_build_intra_predictors_mbuv(VP8D_COMP * pbi,MACROBLOCKD * x,int mb_row,int mb_col)286 void vp8mt_build_intra_predictors_mbuv(VP8D_COMP *pbi, MACROBLOCKD *x, int mb_row, int mb_col)
287 {
288 unsigned char *uabove_row; /* = x->dst.u_buffer - x->dst.uv_stride; */
289 unsigned char *uleft_col; /*[16];*/
290 unsigned char uleft_buf[8];
291 unsigned char utop_left; /* = uabove_row[-1]; */
292 unsigned char *vabove_row; /* = x->dst.v_buffer - x->dst.uv_stride; */
293 unsigned char *vleft_col; /*[20];*/
294 unsigned char vleft_buf[8];
295 unsigned char vtop_left; /* = vabove_row[-1]; */
296 unsigned char *upred_ptr = &x->predictor[256];
297 unsigned char *vpred_ptr = &x->predictor[320];
298 int i, j;
299
300 if (pbi->common.filter_level)
301 {
302 uabove_row = pbi->mt_uabove_row[mb_row] + mb_col*8 +16;
303 vabove_row = pbi->mt_vabove_row[mb_row] + mb_col*8 +16;
304 uleft_col = pbi->mt_uleft_col[mb_row];
305 vleft_col = pbi->mt_vleft_col[mb_row];
306 } else
307 {
308 uabove_row = x->dst.u_buffer - x->dst.uv_stride;
309 vabove_row = x->dst.v_buffer - x->dst.uv_stride;
310
311 for (i = 0; i < 8; i++)
312 {
313 uleft_buf[i] = x->dst.u_buffer [i* x->dst.uv_stride -1];
314 vleft_buf[i] = x->dst.v_buffer [i* x->dst.uv_stride -1];
315 }
316 uleft_col = uleft_buf;
317 vleft_col = vleft_buf;
318 }
319 utop_left = uabove_row[-1];
320 vtop_left = vabove_row[-1];
321
322 switch (x->mode_info_context->mbmi.uv_mode)
323 {
324 case DC_PRED:
325 {
326 int expected_udc;
327 int expected_vdc;
328 int i;
329 int shift;
330 int Uaverage = 0;
331 int Vaverage = 0;
332
333 if (x->up_available)
334 {
335 for (i = 0; i < 8; i++)
336 {
337 Uaverage += uabove_row[i];
338 Vaverage += vabove_row[i];
339 }
340 }
341
342 if (x->left_available)
343 {
344 for (i = 0; i < 8; i++)
345 {
346 Uaverage += uleft_col[i];
347 Vaverage += vleft_col[i];
348 }
349 }
350
351 if (!x->up_available && !x->left_available)
352 {
353 expected_udc = 128;
354 expected_vdc = 128;
355 }
356 else
357 {
358 shift = 2 + x->up_available + x->left_available;
359 expected_udc = (Uaverage + (1 << (shift - 1))) >> shift;
360 expected_vdc = (Vaverage + (1 << (shift - 1))) >> shift;
361 }
362
363
364 vpx_memset(upred_ptr, expected_udc, 64);
365 vpx_memset(vpred_ptr, expected_vdc, 64);
366
367
368 }
369 break;
370 case V_PRED:
371 {
372 int i;
373
374 for (i = 0; i < 8; i++)
375 {
376 vpx_memcpy(upred_ptr, uabove_row, 8);
377 vpx_memcpy(vpred_ptr, vabove_row, 8);
378 upred_ptr += 8;
379 vpred_ptr += 8;
380 }
381
382 }
383 break;
384 case H_PRED:
385 {
386 int i;
387
388 for (i = 0; i < 8; i++)
389 {
390 vpx_memset(upred_ptr, uleft_col[i], 8);
391 vpx_memset(vpred_ptr, vleft_col[i], 8);
392 upred_ptr += 8;
393 vpred_ptr += 8;
394 }
395 }
396
397 break;
398 case TM_PRED:
399 {
400 int i;
401
402 for (i = 0; i < 8; i++)
403 {
404 for (j = 0; j < 8; j++)
405 {
406 int predu = uleft_col[i] + uabove_row[j] - utop_left;
407 int predv = vleft_col[i] + vabove_row[j] - vtop_left;
408
409 if (predu < 0)
410 predu = 0;
411
412 if (predu > 255)
413 predu = 255;
414
415 if (predv < 0)
416 predv = 0;
417
418 if (predv > 255)
419 predv = 255;
420
421 upred_ptr[j] = predu;
422 vpred_ptr[j] = predv;
423 }
424
425 upred_ptr += 8;
426 vpred_ptr += 8;
427 }
428
429 }
430 break;
431 case B_PRED:
432 case NEARESTMV:
433 case NEARMV:
434 case ZEROMV:
435 case NEWMV:
436 case SPLITMV:
437 case MB_MODE_COUNT:
438 break;
439 }
440 }
441
vp8mt_build_intra_predictors_mbuv_s(VP8D_COMP * pbi,MACROBLOCKD * x,int mb_row,int mb_col)442 void vp8mt_build_intra_predictors_mbuv_s(VP8D_COMP *pbi, MACROBLOCKD *x, int mb_row, int mb_col)
443 {
444 unsigned char *uabove_row; /* = x->dst.u_buffer - x->dst.uv_stride; */
445 unsigned char *uleft_col; /*[16];*/
446 unsigned char uleft_buf[8];
447 unsigned char utop_left; /* = uabove_row[-1]; */
448 unsigned char *vabove_row; /* = x->dst.v_buffer - x->dst.uv_stride; */
449 unsigned char *vleft_col; /*[20];*/
450 unsigned char vleft_buf[8];
451 unsigned char vtop_left; /* = vabove_row[-1]; */
452 unsigned char *upred_ptr = x->dst.u_buffer; /*&x->predictor[256];*/
453 unsigned char *vpred_ptr = x->dst.v_buffer; /*&x->predictor[320];*/
454 int uv_stride = x->dst.uv_stride;
455 int i, j;
456
457 if (pbi->common.filter_level)
458 {
459 uabove_row = pbi->mt_uabove_row[mb_row] + mb_col*8 +16;
460 vabove_row = pbi->mt_vabove_row[mb_row] + mb_col*8 +16;
461 uleft_col = pbi->mt_uleft_col[mb_row];
462 vleft_col = pbi->mt_vleft_col[mb_row];
463 } else
464 {
465 uabove_row = x->dst.u_buffer - x->dst.uv_stride;
466 vabove_row = x->dst.v_buffer - x->dst.uv_stride;
467
468 for (i = 0; i < 8; i++)
469 {
470 uleft_buf[i] = x->dst.u_buffer [i* x->dst.uv_stride -1];
471 vleft_buf[i] = x->dst.v_buffer [i* x->dst.uv_stride -1];
472 }
473 uleft_col = uleft_buf;
474 vleft_col = vleft_buf;
475 }
476 utop_left = uabove_row[-1];
477 vtop_left = vabove_row[-1];
478
479 switch (x->mode_info_context->mbmi.uv_mode)
480 {
481 case DC_PRED:
482 {
483 int expected_udc;
484 int expected_vdc;
485 int i;
486 int shift;
487 int Uaverage = 0;
488 int Vaverage = 0;
489
490 if (x->up_available)
491 {
492 for (i = 0; i < 8; i++)
493 {
494 Uaverage += uabove_row[i];
495 Vaverage += vabove_row[i];
496 }
497 }
498
499 if (x->left_available)
500 {
501 for (i = 0; i < 8; i++)
502 {
503 Uaverage += uleft_col[i];
504 Vaverage += vleft_col[i];
505 }
506 }
507
508 if (!x->up_available && !x->left_available)
509 {
510 expected_udc = 128;
511 expected_vdc = 128;
512 }
513 else
514 {
515 shift = 2 + x->up_available + x->left_available;
516 expected_udc = (Uaverage + (1 << (shift - 1))) >> shift;
517 expected_vdc = (Vaverage + (1 << (shift - 1))) >> shift;
518 }
519
520
521 /*vpx_memset(upred_ptr,expected_udc,64);
522 vpx_memset(vpred_ptr,expected_vdc,64);*/
523 for (i = 0; i < 8; i++)
524 {
525 vpx_memset(upred_ptr, expected_udc, 8);
526 vpx_memset(vpred_ptr, expected_vdc, 8);
527 upred_ptr += uv_stride; /*8;*/
528 vpred_ptr += uv_stride; /*8;*/
529 }
530 }
531 break;
532 case V_PRED:
533 {
534 int i;
535
536 for (i = 0; i < 8; i++)
537 {
538 vpx_memcpy(upred_ptr, uabove_row, 8);
539 vpx_memcpy(vpred_ptr, vabove_row, 8);
540 upred_ptr += uv_stride; /*8;*/
541 vpred_ptr += uv_stride; /*8;*/
542 }
543
544 }
545 break;
546 case H_PRED:
547 {
548 int i;
549
550 for (i = 0; i < 8; i++)
551 {
552 vpx_memset(upred_ptr, uleft_col[i], 8);
553 vpx_memset(vpred_ptr, vleft_col[i], 8);
554 upred_ptr += uv_stride; /*8;*/
555 vpred_ptr += uv_stride; /*8;*/
556 }
557 }
558
559 break;
560 case TM_PRED:
561 {
562 int i;
563
564 for (i = 0; i < 8; i++)
565 {
566 for (j = 0; j < 8; j++)
567 {
568 int predu = uleft_col[i] + uabove_row[j] - utop_left;
569 int predv = vleft_col[i] + vabove_row[j] - vtop_left;
570
571 if (predu < 0)
572 predu = 0;
573
574 if (predu > 255)
575 predu = 255;
576
577 if (predv < 0)
578 predv = 0;
579
580 if (predv > 255)
581 predv = 255;
582
583 upred_ptr[j] = predu;
584 vpred_ptr[j] = predv;
585 }
586
587 upred_ptr += uv_stride; /*8;*/
588 vpred_ptr += uv_stride; /*8;*/
589 }
590
591 }
592 break;
593 case B_PRED:
594 case NEARESTMV:
595 case NEARMV:
596 case ZEROMV:
597 case NEWMV:
598 case SPLITMV:
599 case MB_MODE_COUNT:
600 break;
601 }
602 }
603
604
vp8mt_predict_intra4x4(VP8D_COMP * pbi,MACROBLOCKD * xd,int b_mode,unsigned char * predictor,int mb_row,int mb_col,int num)605 void vp8mt_predict_intra4x4(VP8D_COMP *pbi,
606 MACROBLOCKD *xd,
607 int b_mode,
608 unsigned char *predictor,
609 int mb_row,
610 int mb_col,
611 int num)
612 {
613 int i, r, c;
614
615 unsigned char *Above; /* = *(x->base_dst) + x->dst - x->dst_stride; */
616 unsigned char Left[4];
617 unsigned char top_left; /* = Above[-1]; */
618
619 BLOCKD *x = &xd->block[num];
620
621 /*Caution: For some b_mode, it needs 8 pixels (4 above + 4 above-right).*/
622 if (num < 4 && pbi->common.filter_level)
623 Above = pbi->mt_yabove_row[mb_row] + mb_col*16 + num*4 + 32;
624 else
625 Above = *(x->base_dst) + x->dst - x->dst_stride;
626
627 if (num%4==0 && pbi->common.filter_level)
628 {
629 for (i=0; i<4; i++)
630 Left[i] = pbi->mt_yleft_col[mb_row][num + i];
631 }else
632 {
633 Left[0] = (*(x->base_dst))[x->dst - 1];
634 Left[1] = (*(x->base_dst))[x->dst - 1 + x->dst_stride];
635 Left[2] = (*(x->base_dst))[x->dst - 1 + 2 * x->dst_stride];
636 Left[3] = (*(x->base_dst))[x->dst - 1 + 3 * x->dst_stride];
637 }
638
639 if ((num==4 || num==8 || num==12) && pbi->common.filter_level)
640 top_left = pbi->mt_yleft_col[mb_row][num-1];
641 else
642 top_left = Above[-1];
643
644 switch (b_mode)
645 {
646 case B_DC_PRED:
647 {
648 int expected_dc = 0;
649
650 for (i = 0; i < 4; i++)
651 {
652 expected_dc += Above[i];
653 expected_dc += Left[i];
654 }
655
656 expected_dc = (expected_dc + 4) >> 3;
657
658 for (r = 0; r < 4; r++)
659 {
660 for (c = 0; c < 4; c++)
661 {
662 predictor[c] = expected_dc;
663 }
664
665 predictor += 16;
666 }
667 }
668 break;
669 case B_TM_PRED:
670 {
671 /* prediction similar to true_motion prediction */
672 for (r = 0; r < 4; r++)
673 {
674 for (c = 0; c < 4; c++)
675 {
676 int pred = Above[c] - top_left + Left[r];
677
678 if (pred < 0)
679 pred = 0;
680
681 if (pred > 255)
682 pred = 255;
683
684 predictor[c] = pred;
685 }
686
687 predictor += 16;
688 }
689 }
690 break;
691
692 case B_VE_PRED:
693 {
694
695 unsigned int ap[4];
696 ap[0] = (top_left + 2 * Above[0] + Above[1] + 2) >> 2;
697 ap[1] = (Above[0] + 2 * Above[1] + Above[2] + 2) >> 2;
698 ap[2] = (Above[1] + 2 * Above[2] + Above[3] + 2) >> 2;
699 ap[3] = (Above[2] + 2 * Above[3] + Above[4] + 2) >> 2;
700
701 for (r = 0; r < 4; r++)
702 {
703 for (c = 0; c < 4; c++)
704 {
705
706 predictor[c] = ap[c];
707 }
708
709 predictor += 16;
710 }
711
712 }
713 break;
714
715
716 case B_HE_PRED:
717 {
718
719 unsigned int lp[4];
720 lp[0] = (top_left + 2 * Left[0] + Left[1] + 2) >> 2;
721 lp[1] = (Left[0] + 2 * Left[1] + Left[2] + 2) >> 2;
722 lp[2] = (Left[1] + 2 * Left[2] + Left[3] + 2) >> 2;
723 lp[3] = (Left[2] + 2 * Left[3] + Left[3] + 2) >> 2;
724
725 for (r = 0; r < 4; r++)
726 {
727 for (c = 0; c < 4; c++)
728 {
729 predictor[c] = lp[r];
730 }
731
732 predictor += 16;
733 }
734 }
735 break;
736 case B_LD_PRED:
737 {
738 unsigned char *ptr = Above;
739 predictor[0 * 16 + 0] = (ptr[0] + ptr[1] * 2 + ptr[2] + 2) >> 2;
740 predictor[0 * 16 + 1] =
741 predictor[1 * 16 + 0] = (ptr[1] + ptr[2] * 2 + ptr[3] + 2) >> 2;
742 predictor[0 * 16 + 2] =
743 predictor[1 * 16 + 1] =
744 predictor[2 * 16 + 0] = (ptr[2] + ptr[3] * 2 + ptr[4] + 2) >> 2;
745 predictor[0 * 16 + 3] =
746 predictor[1 * 16 + 2] =
747 predictor[2 * 16 + 1] =
748 predictor[3 * 16 + 0] = (ptr[3] + ptr[4] * 2 + ptr[5] + 2) >> 2;
749 predictor[1 * 16 + 3] =
750 predictor[2 * 16 + 2] =
751 predictor[3 * 16 + 1] = (ptr[4] + ptr[5] * 2 + ptr[6] + 2) >> 2;
752 predictor[2 * 16 + 3] =
753 predictor[3 * 16 + 2] = (ptr[5] + ptr[6] * 2 + ptr[7] + 2) >> 2;
754 predictor[3 * 16 + 3] = (ptr[6] + ptr[7] * 2 + ptr[7] + 2) >> 2;
755
756 }
757 break;
758 case B_RD_PRED:
759 {
760
761 unsigned char pp[9];
762
763 pp[0] = Left[3];
764 pp[1] = Left[2];
765 pp[2] = Left[1];
766 pp[3] = Left[0];
767 pp[4] = top_left;
768 pp[5] = Above[0];
769 pp[6] = Above[1];
770 pp[7] = Above[2];
771 pp[8] = Above[3];
772
773 predictor[3 * 16 + 0] = (pp[0] + pp[1] * 2 + pp[2] + 2) >> 2;
774 predictor[3 * 16 + 1] =
775 predictor[2 * 16 + 0] = (pp[1] + pp[2] * 2 + pp[3] + 2) >> 2;
776 predictor[3 * 16 + 2] =
777 predictor[2 * 16 + 1] =
778 predictor[1 * 16 + 0] = (pp[2] + pp[3] * 2 + pp[4] + 2) >> 2;
779 predictor[3 * 16 + 3] =
780 predictor[2 * 16 + 2] =
781 predictor[1 * 16 + 1] =
782 predictor[0 * 16 + 0] = (pp[3] + pp[4] * 2 + pp[5] + 2) >> 2;
783 predictor[2 * 16 + 3] =
784 predictor[1 * 16 + 2] =
785 predictor[0 * 16 + 1] = (pp[4] + pp[5] * 2 + pp[6] + 2) >> 2;
786 predictor[1 * 16 + 3] =
787 predictor[0 * 16 + 2] = (pp[5] + pp[6] * 2 + pp[7] + 2) >> 2;
788 predictor[0 * 16 + 3] = (pp[6] + pp[7] * 2 + pp[8] + 2) >> 2;
789
790 }
791 break;
792 case B_VR_PRED:
793 {
794
795 unsigned char pp[9];
796
797 pp[0] = Left[3];
798 pp[1] = Left[2];
799 pp[2] = Left[1];
800 pp[3] = Left[0];
801 pp[4] = top_left;
802 pp[5] = Above[0];
803 pp[6] = Above[1];
804 pp[7] = Above[2];
805 pp[8] = Above[3];
806
807
808 predictor[3 * 16 + 0] = (pp[1] + pp[2] * 2 + pp[3] + 2) >> 2;
809 predictor[2 * 16 + 0] = (pp[2] + pp[3] * 2 + pp[4] + 2) >> 2;
810 predictor[3 * 16 + 1] =
811 predictor[1 * 16 + 0] = (pp[3] + pp[4] * 2 + pp[5] + 2) >> 2;
812 predictor[2 * 16 + 1] =
813 predictor[0 * 16 + 0] = (pp[4] + pp[5] + 1) >> 1;
814 predictor[3 * 16 + 2] =
815 predictor[1 * 16 + 1] = (pp[4] + pp[5] * 2 + pp[6] + 2) >> 2;
816 predictor[2 * 16 + 2] =
817 predictor[0 * 16 + 1] = (pp[5] + pp[6] + 1) >> 1;
818 predictor[3 * 16 + 3] =
819 predictor[1 * 16 + 2] = (pp[5] + pp[6] * 2 + pp[7] + 2) >> 2;
820 predictor[2 * 16 + 3] =
821 predictor[0 * 16 + 2] = (pp[6] + pp[7] + 1) >> 1;
822 predictor[1 * 16 + 3] = (pp[6] + pp[7] * 2 + pp[8] + 2) >> 2;
823 predictor[0 * 16 + 3] = (pp[7] + pp[8] + 1) >> 1;
824
825 }
826 break;
827 case B_VL_PRED:
828 {
829
830 unsigned char *pp = Above;
831
832 predictor[0 * 16 + 0] = (pp[0] + pp[1] + 1) >> 1;
833 predictor[1 * 16 + 0] = (pp[0] + pp[1] * 2 + pp[2] + 2) >> 2;
834 predictor[2 * 16 + 0] =
835 predictor[0 * 16 + 1] = (pp[1] + pp[2] + 1) >> 1;
836 predictor[1 * 16 + 1] =
837 predictor[3 * 16 + 0] = (pp[1] + pp[2] * 2 + pp[3] + 2) >> 2;
838 predictor[2 * 16 + 1] =
839 predictor[0 * 16 + 2] = (pp[2] + pp[3] + 1) >> 1;
840 predictor[3 * 16 + 1] =
841 predictor[1 * 16 + 2] = (pp[2] + pp[3] * 2 + pp[4] + 2) >> 2;
842 predictor[0 * 16 + 3] =
843 predictor[2 * 16 + 2] = (pp[3] + pp[4] + 1) >> 1;
844 predictor[1 * 16 + 3] =
845 predictor[3 * 16 + 2] = (pp[3] + pp[4] * 2 + pp[5] + 2) >> 2;
846 predictor[2 * 16 + 3] = (pp[4] + pp[5] * 2 + pp[6] + 2) >> 2;
847 predictor[3 * 16 + 3] = (pp[5] + pp[6] * 2 + pp[7] + 2) >> 2;
848 }
849 break;
850
851 case B_HD_PRED:
852 {
853 unsigned char pp[9];
854 pp[0] = Left[3];
855 pp[1] = Left[2];
856 pp[2] = Left[1];
857 pp[3] = Left[0];
858 pp[4] = top_left;
859 pp[5] = Above[0];
860 pp[6] = Above[1];
861 pp[7] = Above[2];
862 pp[8] = Above[3];
863
864
865 predictor[3 * 16 + 0] = (pp[0] + pp[1] + 1) >> 1;
866 predictor[3 * 16 + 1] = (pp[0] + pp[1] * 2 + pp[2] + 2) >> 2;
867 predictor[2 * 16 + 0] =
868 predictor[3 * 16 + 2] = (pp[1] + pp[2] + 1) >> 1;
869 predictor[2 * 16 + 1] =
870 predictor[3 * 16 + 3] = (pp[1] + pp[2] * 2 + pp[3] + 2) >> 2;
871 predictor[2 * 16 + 2] =
872 predictor[1 * 16 + 0] = (pp[2] + pp[3] + 1) >> 1;
873 predictor[2 * 16 + 3] =
874 predictor[1 * 16 + 1] = (pp[2] + pp[3] * 2 + pp[4] + 2) >> 2;
875 predictor[1 * 16 + 2] =
876 predictor[0 * 16 + 0] = (pp[3] + pp[4] + 1) >> 1;
877 predictor[1 * 16 + 3] =
878 predictor[0 * 16 + 1] = (pp[3] + pp[4] * 2 + pp[5] + 2) >> 2;
879 predictor[0 * 16 + 2] = (pp[4] + pp[5] * 2 + pp[6] + 2) >> 2;
880 predictor[0 * 16 + 3] = (pp[5] + pp[6] * 2 + pp[7] + 2) >> 2;
881 }
882 break;
883
884
885 case B_HU_PRED:
886 {
887 unsigned char *pp = Left;
888 predictor[0 * 16 + 0] = (pp[0] + pp[1] + 1) >> 1;
889 predictor[0 * 16 + 1] = (pp[0] + pp[1] * 2 + pp[2] + 2) >> 2;
890 predictor[0 * 16 + 2] =
891 predictor[1 * 16 + 0] = (pp[1] + pp[2] + 1) >> 1;
892 predictor[0 * 16 + 3] =
893 predictor[1 * 16 + 1] = (pp[1] + pp[2] * 2 + pp[3] + 2) >> 2;
894 predictor[1 * 16 + 2] =
895 predictor[2 * 16 + 0] = (pp[2] + pp[3] + 1) >> 1;
896 predictor[1 * 16 + 3] =
897 predictor[2 * 16 + 1] = (pp[2] + pp[3] * 2 + pp[3] + 2) >> 2;
898 predictor[2 * 16 + 2] =
899 predictor[2 * 16 + 3] =
900 predictor[3 * 16 + 0] =
901 predictor[3 * 16 + 1] =
902 predictor[3 * 16 + 2] =
903 predictor[3 * 16 + 3] = pp[3];
904 }
905 break;
906
907
908 }
909 }
910
911 /* copy 4 bytes from the above right down so that the 4x4 prediction modes using pixels above and
912 * to the right prediction have filled in pixels to use.
913 */
vp8mt_intra_prediction_down_copy(VP8D_COMP * pbi,MACROBLOCKD * x,int mb_row,int mb_col)914 void vp8mt_intra_prediction_down_copy(VP8D_COMP *pbi, MACROBLOCKD *x, int mb_row, int mb_col)
915 {
916 unsigned char *above_right; /* = *(x->block[0].base_dst) + x->block[0].dst - x->block[0].dst_stride + 16; */
917 unsigned int *src_ptr;
918 unsigned int *dst_ptr0;
919 unsigned int *dst_ptr1;
920 unsigned int *dst_ptr2;
921
922 if (pbi->common.filter_level)
923 above_right = pbi->mt_yabove_row[mb_row] + mb_col*16 + 32 +16;
924 else
925 above_right = *(x->block[0].base_dst) + x->block[0].dst - x->block[0].dst_stride + 16;
926
927 src_ptr = (unsigned int *)above_right;
928 /*dst_ptr0 = (unsigned int *)(above_right + 4 * x->block[0].dst_stride);
929 dst_ptr1 = (unsigned int *)(above_right + 8 * x->block[0].dst_stride);
930 dst_ptr2 = (unsigned int *)(above_right + 12 * x->block[0].dst_stride);*/
931 dst_ptr0 = (unsigned int *)(*(x->block[0].base_dst) + x->block[0].dst + 16 + 3 * x->block[0].dst_stride);
932 dst_ptr1 = (unsigned int *)(*(x->block[0].base_dst) + x->block[0].dst + 16 + 7 * x->block[0].dst_stride);
933 dst_ptr2 = (unsigned int *)(*(x->block[0].base_dst) + x->block[0].dst + 16 + 11 * x->block[0].dst_stride);
934 *dst_ptr0 = *src_ptr;
935 *dst_ptr1 = *src_ptr;
936 *dst_ptr2 = *src_ptr;
937 }
938