PageRenderTime 75ms CodeModel.GetById 17ms app.highlight 52ms RepoModel.GetById 1ms app.codeStats 0ms

/media/libvpx/vp8/decoder/reconintra_mt.c

http://github.com/zpao/v8monkey
C | 937 lines | 765 code | 147 blank | 25 comment | 88 complexity | 3fcca6d2543e021554284991cccb45d9 MD5 | raw file
  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
 22void 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
150void 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
286void 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
442void 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
605void 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 */
914void 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}