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 "recon.h"
14 : #include "reconintra.h"
15 : #include "vpx_mem/vpx_mem.h"
16 :
17 : /* For skip_recon_mb(), add vp8_build_intra_predictors_mby_s(MACROBLOCKD *x) and
18 : * vp8_build_intra_predictors_mbuv_s(MACROBLOCKD *x).
19 : */
20 0 : void vp8_recon_intra_mbuv(const vp8_recon_rtcd_vtable_t *rtcd, MACROBLOCKD *x)
21 : {
22 : int i;
23 :
24 0 : for (i = 16; i < 24; i += 2)
25 : {
26 0 : BLOCKD *b = &x->block[i];
27 0 : RECON_INVOKE(rtcd, recon2)(b->predictor, b->diff, *(b->base_dst) + b->dst, b->dst_stride);
28 : }
29 0 : }
30 :
31 0 : void vp8_build_intra_predictors_mby(MACROBLOCKD *x)
32 : {
33 :
34 0 : unsigned char *yabove_row = x->dst.y_buffer - x->dst.y_stride;
35 : unsigned char yleft_col[16];
36 0 : unsigned char ytop_left = yabove_row[-1];
37 0 : unsigned char *ypred_ptr = x->predictor;
38 : int r, c, i;
39 :
40 0 : for (i = 0; i < 16; i++)
41 : {
42 0 : yleft_col[i] = x->dst.y_buffer [i* x->dst.y_stride -1];
43 : }
44 :
45 : /* for Y */
46 0 : switch (x->mode_info_context->mbmi.mode)
47 : {
48 : case DC_PRED:
49 : {
50 : int expected_dc;
51 : int i;
52 : int shift;
53 0 : int average = 0;
54 :
55 :
56 0 : if (x->up_available || x->left_available)
57 : {
58 0 : if (x->up_available)
59 : {
60 0 : for (i = 0; i < 16; i++)
61 : {
62 0 : average += yabove_row[i];
63 : }
64 : }
65 :
66 0 : if (x->left_available)
67 : {
68 :
69 0 : for (i = 0; i < 16; i++)
70 : {
71 0 : average += yleft_col[i];
72 : }
73 :
74 : }
75 :
76 :
77 :
78 0 : shift = 3 + x->up_available + x->left_available;
79 0 : expected_dc = (average + (1 << (shift - 1))) >> shift;
80 : }
81 : else
82 : {
83 0 : expected_dc = 128;
84 : }
85 :
86 0 : vpx_memset(ypred_ptr, expected_dc, 256);
87 : }
88 0 : break;
89 : case V_PRED:
90 : {
91 :
92 0 : for (r = 0; r < 16; r++)
93 : {
94 :
95 0 : ((int *)ypred_ptr)[0] = ((int *)yabove_row)[0];
96 0 : ((int *)ypred_ptr)[1] = ((int *)yabove_row)[1];
97 0 : ((int *)ypred_ptr)[2] = ((int *)yabove_row)[2];
98 0 : ((int *)ypred_ptr)[3] = ((int *)yabove_row)[3];
99 0 : ypred_ptr += 16;
100 : }
101 : }
102 0 : break;
103 : case H_PRED:
104 : {
105 :
106 0 : for (r = 0; r < 16; r++)
107 : {
108 :
109 0 : vpx_memset(ypred_ptr, yleft_col[r], 16);
110 0 : ypred_ptr += 16;
111 : }
112 :
113 : }
114 0 : break;
115 : case TM_PRED:
116 : {
117 :
118 0 : for (r = 0; r < 16; r++)
119 : {
120 0 : for (c = 0; c < 16; c++)
121 : {
122 0 : int pred = yleft_col[r] + yabove_row[ c] - ytop_left;
123 :
124 0 : if (pred < 0)
125 0 : pred = 0;
126 :
127 0 : if (pred > 255)
128 0 : pred = 255;
129 :
130 0 : ypred_ptr[c] = pred;
131 : }
132 :
133 0 : ypred_ptr += 16;
134 : }
135 :
136 : }
137 0 : break;
138 : case B_PRED:
139 : case NEARESTMV:
140 : case NEARMV:
141 : case ZEROMV:
142 : case NEWMV:
143 : case SPLITMV:
144 : case MB_MODE_COUNT:
145 0 : break;
146 : }
147 0 : }
148 :
149 0 : void vp8_build_intra_predictors_mby_s(MACROBLOCKD *x)
150 : {
151 :
152 0 : unsigned char *yabove_row = x->dst.y_buffer - x->dst.y_stride;
153 : unsigned char yleft_col[16];
154 0 : unsigned char ytop_left = yabove_row[-1];
155 0 : unsigned char *ypred_ptr = x->predictor;
156 : int r, c, i;
157 :
158 0 : int y_stride = x->dst.y_stride;
159 0 : ypred_ptr = x->dst.y_buffer; /*x->predictor;*/
160 :
161 0 : for (i = 0; i < 16; i++)
162 : {
163 0 : yleft_col[i] = x->dst.y_buffer [i* x->dst.y_stride -1];
164 : }
165 :
166 : /* for Y */
167 0 : switch (x->mode_info_context->mbmi.mode)
168 : {
169 : case DC_PRED:
170 : {
171 : int expected_dc;
172 : int i;
173 : int shift;
174 0 : int average = 0;
175 :
176 :
177 0 : if (x->up_available || x->left_available)
178 : {
179 0 : if (x->up_available)
180 : {
181 0 : for (i = 0; i < 16; i++)
182 : {
183 0 : average += yabove_row[i];
184 : }
185 : }
186 :
187 0 : if (x->left_available)
188 : {
189 :
190 0 : for (i = 0; i < 16; i++)
191 : {
192 0 : average += yleft_col[i];
193 : }
194 :
195 : }
196 :
197 :
198 :
199 0 : shift = 3 + x->up_available + x->left_available;
200 0 : expected_dc = (average + (1 << (shift - 1))) >> shift;
201 : }
202 : else
203 : {
204 0 : expected_dc = 128;
205 : }
206 :
207 : /*vpx_memset(ypred_ptr, expected_dc, 256);*/
208 0 : for (r = 0; r < 16; r++)
209 : {
210 0 : vpx_memset(ypred_ptr, expected_dc, 16);
211 0 : ypred_ptr += y_stride; /*16;*/
212 : }
213 : }
214 0 : break;
215 : case V_PRED:
216 : {
217 :
218 0 : for (r = 0; r < 16; r++)
219 : {
220 :
221 0 : ((int *)ypred_ptr)[0] = ((int *)yabove_row)[0];
222 0 : ((int *)ypred_ptr)[1] = ((int *)yabove_row)[1];
223 0 : ((int *)ypred_ptr)[2] = ((int *)yabove_row)[2];
224 0 : ((int *)ypred_ptr)[3] = ((int *)yabove_row)[3];
225 0 : ypred_ptr += y_stride; /*16;*/
226 : }
227 : }
228 0 : break;
229 : case H_PRED:
230 : {
231 :
232 0 : for (r = 0; r < 16; r++)
233 : {
234 :
235 0 : vpx_memset(ypred_ptr, yleft_col[r], 16);
236 0 : ypred_ptr += y_stride; /*16;*/
237 : }
238 :
239 : }
240 0 : break;
241 : case TM_PRED:
242 : {
243 :
244 0 : for (r = 0; r < 16; r++)
245 : {
246 0 : for (c = 0; c < 16; c++)
247 : {
248 0 : int pred = yleft_col[r] + yabove_row[ c] - ytop_left;
249 :
250 0 : if (pred < 0)
251 0 : pred = 0;
252 :
253 0 : if (pred > 255)
254 0 : pred = 255;
255 :
256 0 : ypred_ptr[c] = pred;
257 : }
258 :
259 0 : ypred_ptr += y_stride; /*16;*/
260 : }
261 :
262 : }
263 0 : break;
264 : case B_PRED:
265 : case NEARESTMV:
266 : case NEARMV:
267 : case ZEROMV:
268 : case NEWMV:
269 : case SPLITMV:
270 : case MB_MODE_COUNT:
271 0 : break;
272 : }
273 0 : }
274 :
275 0 : void vp8_build_intra_predictors_mbuv(MACROBLOCKD *x)
276 : {
277 0 : unsigned char *uabove_row = x->dst.u_buffer - x->dst.uv_stride;
278 : unsigned char uleft_col[16];
279 0 : unsigned char utop_left = uabove_row[-1];
280 0 : unsigned char *vabove_row = x->dst.v_buffer - x->dst.uv_stride;
281 : unsigned char vleft_col[20];
282 0 : unsigned char vtop_left = vabove_row[-1];
283 0 : unsigned char *upred_ptr = &x->predictor[256];
284 0 : unsigned char *vpred_ptr = &x->predictor[320];
285 : int i, j;
286 :
287 0 : for (i = 0; i < 8; i++)
288 : {
289 0 : uleft_col[i] = x->dst.u_buffer [i* x->dst.uv_stride -1];
290 0 : vleft_col[i] = x->dst.v_buffer [i* x->dst.uv_stride -1];
291 : }
292 :
293 0 : switch (x->mode_info_context->mbmi.uv_mode)
294 : {
295 : case DC_PRED:
296 : {
297 : int expected_udc;
298 : int expected_vdc;
299 : int i;
300 : int shift;
301 0 : int Uaverage = 0;
302 0 : int Vaverage = 0;
303 :
304 0 : if (x->up_available)
305 : {
306 0 : for (i = 0; i < 8; i++)
307 : {
308 0 : Uaverage += uabove_row[i];
309 0 : Vaverage += vabove_row[i];
310 : }
311 : }
312 :
313 0 : if (x->left_available)
314 : {
315 0 : for (i = 0; i < 8; i++)
316 : {
317 0 : Uaverage += uleft_col[i];
318 0 : Vaverage += vleft_col[i];
319 : }
320 : }
321 :
322 0 : if (!x->up_available && !x->left_available)
323 : {
324 0 : expected_udc = 128;
325 0 : expected_vdc = 128;
326 : }
327 : else
328 : {
329 0 : shift = 2 + x->up_available + x->left_available;
330 0 : expected_udc = (Uaverage + (1 << (shift - 1))) >> shift;
331 0 : expected_vdc = (Vaverage + (1 << (shift - 1))) >> shift;
332 : }
333 :
334 :
335 0 : vpx_memset(upred_ptr, expected_udc, 64);
336 0 : vpx_memset(vpred_ptr, expected_vdc, 64);
337 :
338 :
339 : }
340 0 : break;
341 : case V_PRED:
342 : {
343 : int i;
344 :
345 0 : for (i = 0; i < 8; i++)
346 : {
347 0 : vpx_memcpy(upred_ptr, uabove_row, 8);
348 0 : vpx_memcpy(vpred_ptr, vabove_row, 8);
349 0 : upred_ptr += 8;
350 0 : vpred_ptr += 8;
351 : }
352 :
353 : }
354 0 : break;
355 : case H_PRED:
356 : {
357 : int i;
358 :
359 0 : for (i = 0; i < 8; i++)
360 : {
361 0 : vpx_memset(upred_ptr, uleft_col[i], 8);
362 0 : vpx_memset(vpred_ptr, vleft_col[i], 8);
363 0 : upred_ptr += 8;
364 0 : vpred_ptr += 8;
365 : }
366 : }
367 :
368 0 : break;
369 : case TM_PRED:
370 : {
371 : int i;
372 :
373 0 : for (i = 0; i < 8; i++)
374 : {
375 0 : for (j = 0; j < 8; j++)
376 : {
377 0 : int predu = uleft_col[i] + uabove_row[j] - utop_left;
378 0 : int predv = vleft_col[i] + vabove_row[j] - vtop_left;
379 :
380 0 : if (predu < 0)
381 0 : predu = 0;
382 :
383 0 : if (predu > 255)
384 0 : predu = 255;
385 :
386 0 : if (predv < 0)
387 0 : predv = 0;
388 :
389 0 : if (predv > 255)
390 0 : predv = 255;
391 :
392 0 : upred_ptr[j] = predu;
393 0 : vpred_ptr[j] = predv;
394 : }
395 :
396 0 : upred_ptr += 8;
397 0 : vpred_ptr += 8;
398 : }
399 :
400 : }
401 0 : break;
402 : case B_PRED:
403 : case NEARESTMV:
404 : case NEARMV:
405 : case ZEROMV:
406 : case NEWMV:
407 : case SPLITMV:
408 : case MB_MODE_COUNT:
409 0 : break;
410 : }
411 0 : }
412 :
413 0 : void vp8_build_intra_predictors_mbuv_s(MACROBLOCKD *x)
414 : {
415 0 : unsigned char *uabove_row = x->dst.u_buffer - x->dst.uv_stride;
416 : unsigned char uleft_col[16];
417 0 : unsigned char utop_left = uabove_row[-1];
418 0 : unsigned char *vabove_row = x->dst.v_buffer - x->dst.uv_stride;
419 : unsigned char vleft_col[20];
420 0 : unsigned char vtop_left = vabove_row[-1];
421 0 : unsigned char *upred_ptr = x->dst.u_buffer; /*&x->predictor[256];*/
422 0 : unsigned char *vpred_ptr = x->dst.v_buffer; /*&x->predictor[320];*/
423 0 : int uv_stride = x->dst.uv_stride;
424 :
425 : int i, j;
426 :
427 0 : for (i = 0; i < 8; i++)
428 : {
429 0 : uleft_col[i] = x->dst.u_buffer [i* x->dst.uv_stride -1];
430 0 : vleft_col[i] = x->dst.v_buffer [i* x->dst.uv_stride -1];
431 : }
432 :
433 0 : switch (x->mode_info_context->mbmi.uv_mode)
434 : {
435 : case DC_PRED:
436 : {
437 : int expected_udc;
438 : int expected_vdc;
439 : int i;
440 : int shift;
441 0 : int Uaverage = 0;
442 0 : int Vaverage = 0;
443 :
444 0 : if (x->up_available)
445 : {
446 0 : for (i = 0; i < 8; i++)
447 : {
448 0 : Uaverage += uabove_row[i];
449 0 : Vaverage += vabove_row[i];
450 : }
451 : }
452 :
453 0 : if (x->left_available)
454 : {
455 0 : for (i = 0; i < 8; i++)
456 : {
457 0 : Uaverage += uleft_col[i];
458 0 : Vaverage += vleft_col[i];
459 : }
460 : }
461 :
462 0 : if (!x->up_available && !x->left_available)
463 : {
464 0 : expected_udc = 128;
465 0 : expected_vdc = 128;
466 : }
467 : else
468 : {
469 0 : shift = 2 + x->up_available + x->left_available;
470 0 : expected_udc = (Uaverage + (1 << (shift - 1))) >> shift;
471 0 : expected_vdc = (Vaverage + (1 << (shift - 1))) >> shift;
472 : }
473 :
474 :
475 : /*vpx_memset(upred_ptr,expected_udc,64);*/
476 : /*vpx_memset(vpred_ptr,expected_vdc,64);*/
477 0 : for (i = 0; i < 8; i++)
478 : {
479 0 : vpx_memset(upred_ptr, expected_udc, 8);
480 0 : vpx_memset(vpred_ptr, expected_vdc, 8);
481 0 : upred_ptr += uv_stride; /*8;*/
482 0 : vpred_ptr += uv_stride; /*8;*/
483 : }
484 : }
485 0 : break;
486 : case V_PRED:
487 : {
488 : int i;
489 :
490 0 : for (i = 0; i < 8; i++)
491 : {
492 0 : vpx_memcpy(upred_ptr, uabove_row, 8);
493 0 : vpx_memcpy(vpred_ptr, vabove_row, 8);
494 0 : upred_ptr += uv_stride; /*8;*/
495 0 : vpred_ptr += uv_stride; /*8;*/
496 : }
497 :
498 : }
499 0 : break;
500 : case H_PRED:
501 : {
502 : int i;
503 :
504 0 : for (i = 0; i < 8; i++)
505 : {
506 0 : vpx_memset(upred_ptr, uleft_col[i], 8);
507 0 : vpx_memset(vpred_ptr, vleft_col[i], 8);
508 0 : upred_ptr += uv_stride; /*8;*/
509 0 : vpred_ptr += uv_stride; /*8;*/
510 : }
511 : }
512 :
513 0 : break;
514 : case TM_PRED:
515 : {
516 : int i;
517 :
518 0 : for (i = 0; i < 8; i++)
519 : {
520 0 : for (j = 0; j < 8; j++)
521 : {
522 0 : int predu = uleft_col[i] + uabove_row[j] - utop_left;
523 0 : int predv = vleft_col[i] + vabove_row[j] - vtop_left;
524 :
525 0 : if (predu < 0)
526 0 : predu = 0;
527 :
528 0 : if (predu > 255)
529 0 : predu = 255;
530 :
531 0 : if (predv < 0)
532 0 : predv = 0;
533 :
534 0 : if (predv > 255)
535 0 : predv = 255;
536 :
537 0 : upred_ptr[j] = predu;
538 0 : vpred_ptr[j] = predv;
539 : }
540 :
541 0 : upred_ptr += uv_stride; /*8;*/
542 0 : vpred_ptr += uv_stride; /*8;*/
543 : }
544 :
545 : }
546 0 : break;
547 : case B_PRED:
548 : case NEARESTMV:
549 : case NEARMV:
550 : case ZEROMV:
551 : case NEWMV:
552 : case SPLITMV:
553 : case MB_MODE_COUNT:
554 0 : break;
555 : }
556 0 : }
|