• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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