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