?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Merge "documentation: minor cosmetics"
[libvpx.git] / vp8 / common / postproc.c
blobd30068ef5a3e7478c8f13b8a48ba6d5204c76e1d
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 "vpx_scale/yv12config.h"
14 #include "postproc.h"
15 #include "vpx_scale/yv12extend.h"
16 #include "vpx_scale/vpxscale.h"
17 #include "systemdependent.h"
18
19 #include <math.h>
20 #include <stdlib.h>
21 #include <stdio.h>
22
23 #define RGB_TO_YUV(t) \
24 ( (0.257*(float)(t>>16)) + (0.504*(float)(t>>8&0xff)) + (0.098*(float)(t&0xff)) + 16), \
25 (-(0.148*(float)(t>>16)) - (0.291*(float)(t>>8&0xff)) + (0.439*(float)(t&0xff)) + 128), \
26 ( (0.439*(float)(t>>16)) - (0.368*(float)(t>>8&0xff)) - (0.071*(float)(t&0xff)) + 128)
27
28 /* global constants */
29 #if CONFIG_POSTPROC_VISUALIZER
30 static const unsigned char MB_PREDICTION_MODE_colors[MB_MODE_COUNT][3] =
31 {
32 { RGB_TO_YUV(0x98FB98) }, /* PaleGreen */
33 { RGB_TO_YUV(0x00FF00) }, /* Green */
34 { RGB_TO_YUV(0xADFF2F) }, /* GreenYellow */
35 { RGB_TO_YUV(0x228B22) }, /* ForestGreen */
36 { RGB_TO_YUV(0x006400) }, /* DarkGreen */
37 { RGB_TO_YUV(0x98F5FF) }, /* Cadet Blue */
38 { RGB_TO_YUV(0x6CA6CD) }, /* Sky Blue */
39 { RGB_TO_YUV(0x00008B) }, /* Dark blue */
40 { RGB_TO_YUV(0x551A8B) }, /* Purple */
41 { RGB_TO_YUV(0xFF0000) } /* Red */
42 };
43
44 static const unsigned char B_PREDICTION_MODE_colors[B_MODE_COUNT][3] =
45 {
46 { RGB_TO_YUV(0x6633ff) }, /* Purple */
47 { RGB_TO_YUV(0xcc33ff) }, /* Magenta */
48 { RGB_TO_YUV(0xff33cc) }, /* Pink */
49 { RGB_TO_YUV(0xff3366) }, /* Coral */
50 { RGB_TO_YUV(0x3366ff) }, /* Blue */
51 { RGB_TO_YUV(0xed00f5) }, /* Dark Blue */
52 { RGB_TO_YUV(0x2e00b8) }, /* Dark Purple */
53 { RGB_TO_YUV(0xff6633) }, /* Orange */
54 { RGB_TO_YUV(0x33ccff) }, /* Light Blue */
55 { RGB_TO_YUV(0x8ab800) }, /* Green */
56 { RGB_TO_YUV(0xffcc33) }, /* Light Orange */
57 { RGB_TO_YUV(0x33ffcc) }, /* Aqua */
58 { RGB_TO_YUV(0x66ff33) }, /* Light Green */
59 { RGB_TO_YUV(0xccff33) }, /* Yellow */
60 };
61
62 static const unsigned char MV_REFERENCE_FRAME_colors[MAX_REF_FRAMES][3] =
63 {
64 { RGB_TO_YUV(0x00ff00) }, /* Blue */
65 { RGB_TO_YUV(0x0000ff) }, /* Green */
66 { RGB_TO_YUV(0xffff00) }, /* Yellow */
67 { RGB_TO_YUV(0xff0000) }, /* Red */
68 };
69 #endif
70
71 static const short kernel5[] =
72 {
73 1, 1, 4, 1, 1
74 };
75
76 const short vp8_rv[] =
77 {
78 8, 5, 2, 2, 8, 12, 4, 9, 8, 3,
79 0, 3, 9, 0, 0, 0, 8, 3, 14, 4,
80 10, 1, 11, 14, 1, 14, 9, 6, 12, 11,
81 8, 6, 10, 0, 0, 8, 9, 0, 3, 14,
82 8, 11, 13, 4, 2, 9, 0, 3, 9, 6,
83 1, 2, 3, 14, 13, 1, 8, 2, 9, 7,
84 3, 3, 1, 13, 13, 6, 6, 5, 2, 7,
85 11, 9, 11, 8, 7, 3, 2, 0, 13, 13,
86 14, 4, 12, 5, 12, 10, 8, 10, 13, 10,
87 4, 14, 4, 10, 0, 8, 11, 1, 13, 7,
88 7, 14, 6, 14, 13, 2, 13, 5, 4, 4,
89 0, 10, 0, 5, 13, 2, 12, 7, 11, 13,
90 8, 0, 4, 10, 7, 2, 7, 2, 2, 5,
91 3, 4, 7, 3, 3, 14, 14, 5, 9, 13,
92 3, 14, 3, 6, 3, 0, 11, 8, 13, 1,
93 13, 1, 12, 0, 10, 9, 7, 6, 2, 8,
94 5, 2, 13, 7, 1, 13, 14, 7, 6, 7,
95 9, 6, 10, 11, 7, 8, 7, 5, 14, 8,
96 4, 4, 0, 8, 7, 10, 0, 8, 14, 11,
97 3, 12, 5, 7, 14, 3, 14, 5, 2, 6,
98 11, 12, 12, 8, 0, 11, 13, 1, 2, 0,
99 5, 10, 14, 7, 8, 0, 4, 11, 0, 8,
100 0, 3, 10, 5, 8, 0, 11, 6, 7, 8,
101 10, 7, 13, 9, 2, 5, 1, 5, 10, 2,
102 4, 3, 5, 6, 10, 8, 9, 4, 11, 14,
103 0, 10, 0, 5, 13, 2, 12, 7, 11, 13,
104 8, 0, 4, 10, 7, 2, 7, 2, 2, 5,
105 3, 4, 7, 3, 3, 14, 14, 5, 9, 13,
106 3, 14, 3, 6, 3, 0, 11, 8, 13, 1,
107 13, 1, 12, 0, 10, 9, 7, 6, 2, 8,
108 5, 2, 13, 7, 1, 13, 14, 7, 6, 7,
109 9, 6, 10, 11, 7, 8, 7, 5, 14, 8,
110 4, 4, 0, 8, 7, 10, 0, 8, 14, 11,
111 3, 12, 5, 7, 14, 3, 14, 5, 2, 6,
112 11, 12, 12, 8, 0, 11, 13, 1, 2, 0,
113 5, 10, 14, 7, 8, 0, 4, 11, 0, 8,
114 0, 3, 10, 5, 8, 0, 11, 6, 7, 8,
115 10, 7, 13, 9, 2, 5, 1, 5, 10, 2,
116 4, 3, 5, 6, 10, 8, 9, 4, 11, 14,
117 3, 8, 3, 7, 8, 5, 11, 4, 12, 3,
118 11, 9, 14, 8, 14, 13, 4, 3, 1, 2,
119 14, 6, 5, 4, 4, 11, 4, 6, 2, 1,
120 5, 8, 8, 12, 13, 5, 14, 10, 12, 13,
121 0, 9, 5, 5, 11, 10, 13, 9, 10, 13,
122 };
123
124
125 extern void vp8_blit_text(const char *msg, unsigned char *address, const int pitch);
126 extern void vp8_blit_line(int x0, int x1, int y0, int y1, unsigned char *image, const int pitch);
127 /***********************************************************************************************************
128 */
129 void vp8_post_proc_down_and_across_c
130 (
131 unsigned char *src_ptr,
132 unsigned char *dst_ptr,
133 int src_pixels_per_line,
134 int dst_pixels_per_line,
135 int rows,
136 int cols,
137 int flimit
138 )
139 {
140 unsigned char *p_src, *p_dst;
141 int row;
142 int col;
143 int i;
144 int v;
145 int pitch = src_pixels_per_line;
146 unsigned char d[8];
147 (void)dst_pixels_per_line;
148
149 for (row = 0; row < rows; row++)
150 {
151 /* post_proc_down for one row */
152 p_src = src_ptr;
153 p_dst = dst_ptr;
154
155 for (col = 0; col < cols; col++)
156 {
157
158 int kernel = 4;
159 int v = p_src[col];
160
161 for (i = -2; i <= 2; i++)
162 {
163 if (abs(v - p_src[col+i*pitch]) > flimit)
164 goto down_skip_convolve;
165
166 kernel += kernel5[2+i] * p_src[col+i*pitch];
167 }
168
169 v = (kernel >> 3);
170 down_skip_convolve:
171 p_dst[col] = v;
172 }
173
174 /* now post_proc_across */
175 p_src = dst_ptr;
176 p_dst = dst_ptr;
177
178 for (i = 0; i < 8; i++)
179 d[i] = p_src[i];
180
181 for (col = 0; col < cols; col++)
182 {
183 int kernel = 4;
184 v = p_src[col];
185
186 d[col&7] = v;
187
188 for (i = -2; i <= 2; i++)
189 {
190 if (abs(v - p_src[col+i]) > flimit)
191 goto across_skip_convolve;
192
193 kernel += kernel5[2+i] * p_src[col+i];
194 }
195
196 d[col&7] = (kernel >> 3);
197 across_skip_convolve:
198
199 if (col >= 2)
200 p_dst[col-2] = d[(col-2)&7];
201 }
202
203 /* handle the last two pixels */
204 p_dst[col-2] = d[(col-2)&7];
205 p_dst[col-1] = d[(col-1)&7];
206
207
208 /* next row */
209 src_ptr += pitch;
210 dst_ptr += pitch;
211 }
212 }
213
214 int vp8_q2mbl(int x)
215 {
216 if (x < 20) x = 20;
217
218 x = 50 + (x - 50) * 10 / 8;
219 return x * x / 3;
220 }
221 void vp8_mbpost_proc_across_ip_c(unsigned char *src, int pitch, int rows, int cols, int flimit)
222 {
223 int r, c, i;
224
225 unsigned char *s = src;
226 unsigned char d[16];
227
228
229 for (r = 0; r < rows; r++)
230 {
231 int sumsq = 0;
232 int sum = 0;
233
234 for (i = -8; i <= 6; i++)
235 {
236 sumsq += s[i] * s[i];
237 sum += s[i];
238 d[i+8] = 0;
239 }
240
241 for (c = 0; c < cols + 8; c++)
242 {
243 int x = s[c+7] - s[c-8];
244 int y = s[c+7] + s[c-8];
245
246 sum += x;
247 sumsq += x * y;
248
249 d[c&15] = s[c];
250
251 if (sumsq * 15 - sum * sum < flimit)
252 {
253 d[c&15] = (8 + sum + s[c]) >> 4;
254 }
255
256 s[c-8] = d[(c-8)&15];
257 }
258
259 s += pitch;
260 }
261 }
262
263
264
265
266
267 void vp8_mbpost_proc_down_c(unsigned char *dst, int pitch, int rows, int cols, int flimit)
268 {
269 int r, c, i;
270 const short *rv3 = &vp8_rv[63&rand()];
271
272 for (c = 0; c < cols; c++)
273 {
274 unsigned char *s = &dst[c];
275 int sumsq = 0;
276 int sum = 0;
277 unsigned char d[16];
278 const short *rv2 = rv3 + ((c * 17) & 127);
279
280 for (i = -8; i <= 6; i++)
281 {
282 sumsq += s[i*pitch] * s[i*pitch];
283 sum += s[i*pitch];
284 }
285
286 for (r = 0; r < rows + 8; r++)
287 {
288 sumsq += s[7*pitch] * s[ 7*pitch] - s[-8*pitch] * s[-8*pitch];
289 sum += s[7*pitch] - s[-8*pitch];
290 d[r&15] = s[0];
291
292 if (sumsq * 15 - sum * sum < flimit)
293 {
294 d[r&15] = (rv2[r&127] + sum + s[0]) >> 4;
295 }
296
297 s[-8*pitch] = d[(r-8)&15];
298 s += pitch;
299 }
300 }
301 }
302
303
304 static void vp8_deblock_and_de_macro_block(YV12_BUFFER_CONFIG *source,
305 YV12_BUFFER_CONFIG *post,
306 int q,
307 int low_var_thresh,
308 int flag,
309 vp8_postproc_rtcd_vtable_t *rtcd)
310 {
311 double level = 6.0e-05 * q * q * q - .0067 * q * q + .306 * q + .0065;
312 int ppl = (int)(level + .5);
313 (void) low_var_thresh;
314 (void) flag;
315
316 POSTPROC_INVOKE(rtcd, downacross)(source->y_buffer, post->y_buffer, source->y_stride, post->y_stride, source->y_height, source->y_width, ppl);
317 POSTPROC_INVOKE(rtcd, across)(post->y_buffer, post->y_stride, post->y_height, post->y_width, vp8_q2mbl(q));
318 POSTPROC_INVOKE(rtcd, down)(post->y_buffer, post->y_stride, post->y_height, post->y_width, vp8_q2mbl(q));
319
320 POSTPROC_INVOKE(rtcd, downacross)(source->u_buffer, post->u_buffer, source->uv_stride, post->uv_stride, source->uv_height, source->uv_width, ppl);
321 POSTPROC_INVOKE(rtcd, downacross)(source->v_buffer, post->v_buffer, source->uv_stride, post->uv_stride, source->uv_height, source->uv_width, ppl);
322
323 }
324
325 void vp8_deblock(YV12_BUFFER_CONFIG *source,
326 YV12_BUFFER_CONFIG *post,
327 int q,
328 int low_var_thresh,
329 int flag,
330 vp8_postproc_rtcd_vtable_t *rtcd)
331 {
332 double level = 6.0e-05 * q * q * q - .0067 * q * q + .306 * q + .0065;
333 int ppl = (int)(level + .5);
334 (void) low_var_thresh;
335 (void) flag;
336
337 POSTPROC_INVOKE(rtcd, downacross)(source->y_buffer, post->y_buffer, source->y_stride, post->y_stride, source->y_height, source->y_width, ppl);
338 POSTPROC_INVOKE(rtcd, downacross)(source->u_buffer, post->u_buffer, source->uv_stride, post->uv_stride, source->uv_height, source->uv_width, ppl);
339 POSTPROC_INVOKE(rtcd, downacross)(source->v_buffer, post->v_buffer, source->uv_stride, post->uv_stride, source->uv_height, source->uv_width, ppl);
340 }
341
342 void vp8_de_noise(YV12_BUFFER_CONFIG *source,
343 YV12_BUFFER_CONFIG *post,
344 int q,
345 int low_var_thresh,
346 int flag,
347 vp8_postproc_rtcd_vtable_t *rtcd)
348 {
349 double level = 6.0e-05 * q * q * q - .0067 * q * q + .306 * q + .0065;
350 int ppl = (int)(level + .5);
351 (void) post;
352 (void) low_var_thresh;
353 (void) flag;
354
355 POSTPROC_INVOKE(rtcd, downacross)(
356 source->y_buffer + 2 * source->y_stride + 2,
357 source->y_buffer + 2 * source->y_stride + 2,
358 source->y_stride,
359 source->y_stride,
360 source->y_height - 4,
361 source->y_width - 4,
362 ppl);
363 POSTPROC_INVOKE(rtcd, downacross)(
364 source->u_buffer + 2 * source->uv_stride + 2,
365 source->u_buffer + 2 * source->uv_stride + 2,
366 source->uv_stride,
367 source->uv_stride,
368 source->uv_height - 4,
369 source->uv_width - 4, ppl);
370 POSTPROC_INVOKE(rtcd, downacross)(
371 source->v_buffer + 2 * source->uv_stride + 2,
372 source->v_buffer + 2 * source->uv_stride + 2,
373 source->uv_stride,
374 source->uv_stride,
375 source->uv_height - 4,
376 source->uv_width - 4, ppl);
377
378 }
379
380 double vp8_gaussian(double sigma, double mu, double x)
381 {
382 return 1 / (sigma * sqrt(2.0 * 3.14159265)) *
383 (exp(-(x - mu) * (x - mu) / (2 * sigma * sigma)));
384 }
385
386 extern void (*vp8_clear_system_state)(void);
387
388
389 static void fillrd(struct postproc_state *state, int q, int a)
390 {
391 char char_dist[300];
392
393 double sigma;
394 int ai = a, qi = q, i;
395
396 vp8_clear_system_state();
397
398
399 sigma = ai + .5 + .6 * (63 - qi) / 63.0;
400
401 /* set up a lookup table of 256 entries that matches
402 * a gaussian distribution with sigma determined by q.
403 */
404 {
405 double i;
406 int next, j;
407
408 next = 0;
409
410 for (i = -32; i < 32; i++)
411 {
412 int a = (int)(.5 + 256 * vp8_gaussian(sigma, 0, i));
413
414 if (a)
415 {
416 for (j = 0; j < a; j++)
417 {
418 char_dist[next+j] = (char) i;
419 }
420
421 next = next + j;
422 }
423
424 }
425
426 for (next = next; next < 256; next++)
427 char_dist[next] = 0;
428
429 }
430
431 for (i = 0; i < 3072; i++)
432 {
433 state->noise[i] = char_dist[rand() & 0xff];
434 }
435
436 for (i = 0; i < 16; i++)
437 {
438 state->blackclamp[i] = -char_dist[0];
439 state->whiteclamp[i] = -char_dist[0];
440 state->bothclamp[i] = -2 * char_dist[0];
441 }
442
443 state->last_q = q;
444 state->last_noise = a;
445 }
446
447 /****************************************************************************
448 *
449 * ROUTINE : plane_add_noise_c
450 *
451 * INPUTS : unsigned char *Start starting address of buffer to add gaussian
452 * noise to
453 * unsigned int Width width of plane
454 * unsigned int Height height of plane
455 * int Pitch distance between subsequent lines of frame
456 * int q quantizer used to determine amount of noise
457 * to add
458 *
459 * OUTPUTS : None.
460 *
461 * RETURNS : void.
462 *
463 * FUNCTION : adds gaussian noise to a plane of pixels
464 *
465 * SPECIAL NOTES : None.
466 *
467 ****************************************************************************/
468 void vp8_plane_add_noise_c(unsigned char *Start, char *noise,
469 char blackclamp[16],
470 char whiteclamp[16],
471 char bothclamp[16],
472 unsigned int Width, unsigned int Height, int Pitch)
473 {
474 unsigned int i, j;
475
476 for (i = 0; i < Height; i++)
477 {
478 unsigned char *Pos = Start + i * Pitch;
479 char *Ref = (char *)(noise + (rand() & 0xff));
480
481 for (j = 0; j < Width; j++)
482 {
483 if (Pos[j] < blackclamp[0])
484 Pos[j] = blackclamp[0];
485
486 if (Pos[j] > 255 + whiteclamp[0])
487 Pos[j] = 255 + whiteclamp[0];
488
489 Pos[j] += Ref[j];
490 }
491 }
492 }
493
494 /* Blend the macro block with a solid colored square. Leave the
495 * edges unblended to give distinction to macro blocks in areas
496 * filled with the same color block.
497 */
498 void vp8_blend_mb_inner_c (unsigned char *y, unsigned char *u, unsigned char *v,
499 int y1, int u1, int v1, int alpha, int stride)
500 {
501 int i, j;
502 int y1_const = y1*((1<<16)-alpha);
503 int u1_const = u1*((1<<16)-alpha);
504 int v1_const = v1*((1<<16)-alpha);
505
506 y += 2*stride + 2;
507 for (i = 0; i < 12; i++)
508 {
509 for (j = 0; j < 12; j++)
510 {
511 y[j] = (y[j]*alpha + y1_const)>>16;
512 }
513 y += stride;
514 }
515
516 stride >>= 1;
517
518 u += stride + 1;
519 v += stride + 1;
520
521 for (i = 0; i < 6; i++)
522 {
523 for (j = 0; j < 6; j++)
524 {
525 u[j] = (u[j]*alpha + u1_const)>>16;
526 v[j] = (v[j]*alpha + v1_const)>>16;
527 }
528 u += stride;
529 v += stride;
530 }
531 }
532
533 /* Blend only the edge of the macro block. Leave center
534 * unblended to allow for other visualizations to be layered.
535 */
536 void vp8_blend_mb_outer_c (unsigned char *y, unsigned char *u, unsigned char *v,
537 int y1, int u1, int v1, int alpha, int stride)
538 {
539 int i, j;
540 int y1_const = y1*((1<<16)-alpha);
541 int u1_const = u1*((1<<16)-alpha);
542 int v1_const = v1*((1<<16)-alpha);
543
544 for (i = 0; i < 2; i++)
545 {
546 for (j = 0; j < 16; j++)
547 {
548 y[j] = (y[j]*alpha + y1_const)>>16;
549 }
550 y += stride;
551 }
552
553 for (i = 0; i < 12; i++)
554 {
555 y[0] = (y[0]*alpha + y1_const)>>16;
556 y[1] = (y[1]*alpha + y1_const)>>16;
557 y[14] = (y[14]*alpha + y1_const)>>16;
558 y[15] = (y[15]*alpha + y1_const)>>16;
559 y += stride;
560 }
561
562 for (i = 0; i < 2; i++)
563 {
564 for (j = 0; j < 16; j++)
565 {
566 y[j] = (y[j]*alpha + y1_const)>>16;
567 }
568 y += stride;
569 }
570
571 stride >>= 1;
572
573 for (j = 0; j < 8; j++)
574 {
575 u[j] = (u[j]*alpha + u1_const)>>16;
576 v[j] = (v[j]*alpha + v1_const)>>16;
577 }
578 u += stride;
579 v += stride;
580
581 for (i = 0; i < 6; i++)
582 {
583 u[0] = (u[0]*alpha + u1_const)>>16;
584 v[0] = (v[0]*alpha + v1_const)>>16;
585
586 u[7] = (u[7]*alpha + u1_const)>>16;
587 v[7] = (v[7]*alpha + v1_const)>>16;
588
589 u += stride;
590 v += stride;
591 }
592
593 for (j = 0; j < 8; j++)
594 {
595 u[j] = (u[j]*alpha + u1_const)>>16;
596 v[j] = (v[j]*alpha + v1_const)>>16;
597 }
598 }
599
600 void vp8_blend_b_c (unsigned char *y, unsigned char *u, unsigned char *v,
601 int y1, int u1, int v1, int alpha, int stride)
602 {
603 int i, j;
604 int y1_const = y1*((1<<16)-alpha);
605 int u1_const = u1*((1<<16)-alpha);
606 int v1_const = v1*((1<<16)-alpha);
607
608 for (i = 0; i < 4; i++)
609 {
610 for (j = 0; j < 4; j++)
611 {
612 y[j] = (y[j]*alpha + y1_const)>>16;
613 }
614 y += stride;
615 }
616
617 stride >>= 1;
618
619 for (i = 0; i < 2; i++)
620 {
621 for (j = 0; j < 2; j++)
622 {
623 u[j] = (u[j]*alpha + u1_const)>>16;
624 v[j] = (v[j]*alpha + v1_const)>>16;
625 }
626 u += stride;
627 v += stride;
628 }
629 }
630
631 static void constrain_line (int x0, int *x1, int y0, int *y1, int width, int height)
632 {
633 int dx;
634 int dy;
635
636 if (*x1 > width)
637 {
638 dx = *x1 - x0;
639 dy = *y1 - y0;
640
641 *x1 = width;
642 if (dx)
643 *y1 = ((width-x0)*dy)/dx + y0;
644 }
645 if (*x1 < 0)
646 {
647 dx = *x1 - x0;
648 dy = *y1 - y0;
649
650 *x1 = 0;
651 if (dx)
652 *y1 = ((0-x0)*dy)/dx + y0;
653 }
654 if (*y1 > height)
655 {
656 dx = *x1 - x0;
657 dy = *y1 - y0;
658
659 *y1 = height;
660 if (dy)
661 *x1 = ((height-y0)*dx)/dy + x0;
662 }
663 if (*y1 < 0)
664 {
665 dx = *x1 - x0;
666 dy = *y1 - y0;
667
668 *y1 = 0;
669 if (dy)
670 *x1 = ((0-y0)*dx)/dy + x0;
671 }
672 }
673
674
675 #if CONFIG_RUNTIME_CPU_DETECT
676 #define RTCD_VTABLE(oci) (&(oci)->rtcd.postproc)
677 #else
678 #define RTCD_VTABLE(oci) NULL
679 #endif
680
681 int vp8_post_proc_frame(VP8_COMMON *oci, YV12_BUFFER_CONFIG *dest, vp8_ppflags_t *ppflags)
682 {
683 int q = oci->filter_level * 10 / 6;
684 int flags = ppflags->post_proc_flag;
685 int deblock_level = ppflags->deblocking_level;
686 int noise_level = ppflags->noise_level;
687
688 if (!oci->frame_to_show)
689 return -1;
690
691 if (q > 63)
692 q = 63;
693
694 if (!flags)
695 {
696 *dest = *oci->frame_to_show;
697
698 /* handle problem with extending borders */
699 dest->y_width = oci->Width;
700 dest->y_height = oci->Height;
701 dest->uv_height = dest->y_height / 2;
702 return 0;
703
704 }
705
706 #if ARCH_X86||ARCH_X86_64
707 vpx_reset_mmx_state();
708 #endif
709
710 if (flags & VP8D_DEMACROBLOCK)
711 {
712 vp8_deblock_and_de_macro_block(oci->frame_to_show, &oci->post_proc_buffer,
713 q + (deblock_level - 5) * 10, 1, 0, RTCD_VTABLE(oci));
714 }
715 else if (flags & VP8D_DEBLOCK)
716 {
717 vp8_deblock(oci->frame_to_show, &oci->post_proc_buffer,
718 q, 1, 0, RTCD_VTABLE(oci));
719 }
720 else
721 {
722 vp8_yv12_copy_frame_ptr(oci->frame_to_show, &oci->post_proc_buffer);
723 }
724
725 if (flags & VP8D_ADDNOISE)
726 {
727 if (oci->postproc_state.last_q != q
728 || oci->postproc_state.last_noise != noise_level)
729 {
730 fillrd(&oci->postproc_state, 63 - q, noise_level);
731 }
732
733 POSTPROC_INVOKE(RTCD_VTABLE(oci), addnoise)
734 (oci->post_proc_buffer.y_buffer,
735 oci->postproc_state.noise,
736 oci->postproc_state.blackclamp,
737 oci->postproc_state.whiteclamp,
738 oci->postproc_state.bothclamp,
739 oci->post_proc_buffer.y_width, oci->post_proc_buffer.y_height,
740 oci->post_proc_buffer.y_stride);
741 }
742
743 #if CONFIG_POSTPROC_VISUALIZER
744 if (flags & VP8D_DEBUG_TXT_FRAME_INFO)
745 {
746 char message[512];
747 sprintf(message, "F%1dG%1dQ%3dF%3dP%d_s%dx%d",
748 (oci->frame_type == KEY_FRAME),
749 oci->refresh_golden_frame,
750 oci->base_qindex,
751 oci->filter_level,
752 flags,
753 oci->mb_cols, oci->mb_rows);
754 vp8_blit_text(message, oci->post_proc_buffer.y_buffer, oci->post_proc_buffer.y_stride);
755 }
756
757 if (flags & VP8D_DEBUG_TXT_MBLK_MODES)
758 {
759 int i, j;
760 unsigned char *y_ptr;
761 YV12_BUFFER_CONFIG *post = &oci->post_proc_buffer;
762 int mb_rows = post->y_height >> 4;
763 int mb_cols = post->y_width >> 4;
764 int mb_index = 0;
765 MODE_INFO *mi = oci->mi;
766
767 y_ptr = post->y_buffer + 4 * post->y_stride + 4;
768
769 /* vp8_filter each macro block */
770 for (i = 0; i < mb_rows; i++)
771 {
772 for (j = 0; j < mb_cols; j++)
773 {
774 char zz[4];
775
776 sprintf(zz, "%c", mi[mb_index].mbmi.mode + 'a');
777
778 vp8_blit_text(zz, y_ptr, post->y_stride);
779 mb_index ++;
780 y_ptr += 16;
781 }
782
783 mb_index ++; /* border */
784 y_ptr += post->y_stride * 16 - post->y_width;
785
786 }
787 }
788
789 if (flags & VP8D_DEBUG_TXT_DC_DIFF)
790 {
791 int i, j;
792 unsigned char *y_ptr;
793 YV12_BUFFER_CONFIG *post = &oci->post_proc_buffer;
794 int mb_rows = post->y_height >> 4;
795 int mb_cols = post->y_width >> 4;
796 int mb_index = 0;
797 MODE_INFO *mi = oci->mi;
798
799 y_ptr = post->y_buffer + 4 * post->y_stride + 4;
800
801 /* vp8_filter each macro block */
802 for (i = 0; i < mb_rows; i++)
803 {
804 for (j = 0; j < mb_cols; j++)
805 {
806 char zz[4];
807
808 if (oci->frame_type == KEY_FRAME)
809 sprintf(zz, "a");
810 else
811 sprintf(zz, "%c", mi[mb_index].mbmi.dc_diff + '0');
812
813 vp8_blit_text(zz, y_ptr, post->y_stride);
814 mb_index ++;
815 y_ptr += 16;
816 }
817
818 mb_index ++; /* border */
819 y_ptr += post->y_stride * 16 - post->y_width;
820
821 }
822 }
823
824 if (flags & VP8D_DEBUG_TXT_RATE_INFO)
825 {
826 char message[512];
827 sprintf(message, "Bitrate: %10.2f frame_rate: %10.2f ", oci->bitrate, oci->framerate);
828 vp8_blit_text(message, oci->post_proc_buffer.y_buffer, oci->post_proc_buffer.y_stride);
829 }
830
831 /* Draw motion vectors */
832 if ((flags & VP8D_DEBUG_DRAW_MV) && ppflags->display_mv_flag)
833 {
834 YV12_BUFFER_CONFIG *post = &oci->post_proc_buffer;
835 int width = post->y_width;
836 int height = post->y_height;
837 int mb_cols = width >> 4;
838 unsigned char *y_buffer = oci->post_proc_buffer.y_buffer;
839 int y_stride = oci->post_proc_buffer.y_stride;
840 MODE_INFO *mi = oci->mi;
841 int x0, y0;
842
843 for (y0 = 0; y0 < height; y0 += 16)
844 {
845 for (x0 = 0; x0 < width; x0 += 16)
846 {
847 int x1, y1;
848
849 if (!(ppflags->display_mv_flag & (1<<mi->mbmi.mode)))
850 {
851 mi++;
852 continue;
853 }
854
855 if (mi->mbmi.mode == SPLITMV)
856 {
857 switch (mi->mbmi.partitioning)
858 {
859 case 0 : /* mv_top_bottom */
860 {
861 B_MODE_INFO *bmi = &mi->bmi[0];
862 MV *mv = &bmi->mv.as_mv;
863
864 x1 = x0 + 8 + (mv->col >> 3);
865 y1 = y0 + 4 + (mv->row >> 3);
866
867 constrain_line (x0+8, &x1, y0+4, &y1, width, height);
868 vp8_blit_line (x0+8, x1, y0+4, y1, y_buffer, y_stride);
869
870 bmi = &mi->bmi[8];
871
872 x1 = x0 + 8 + (mv->col >> 3);
873 y1 = y0 +12 + (mv->row >> 3);
874
875 constrain_line (x0+8, &x1, y0+12, &y1, width, height);
876 vp8_blit_line (x0+8, x1, y0+12, y1, y_buffer, y_stride);
877
878 break;
879 }
880 case 1 : /* mv_left_right */
881 {
882 B_MODE_INFO *bmi = &mi->bmi[0];
883 MV *mv = &bmi->mv.as_mv;
884
885 x1 = x0 + 4 + (mv->col >> 3);
886 y1 = y0 + 8 + (mv->row >> 3);
887
888 constrain_line (x0+4, &x1, y0+8, &y1, width, height);
889 vp8_blit_line (x0+4, x1, y0+8, y1, y_buffer, y_stride);
890
891 bmi = &mi->bmi[2];
892
893 x1 = x0 +12 + (mv->col >> 3);
894 y1 = y0 + 8 + (mv->row >> 3);
895
896 constrain_line (x0+12, &x1, y0+8, &y1, width, height);
897 vp8_blit_line (x0+12, x1, y0+8, y1, y_buffer, y_stride);
898
899 break;
900 }
901 case 2 : /* mv_quarters */
902 {
903 B_MODE_INFO *bmi = &mi->bmi[0];
904 MV *mv = &bmi->mv.as_mv;
905
906 x1 = x0 + 4 + (mv->col >> 3);
907 y1 = y0 + 4 + (mv->row >> 3);
908
909 constrain_line (x0+4, &x1, y0+4, &y1, width, height);
910 vp8_blit_line (x0+4, x1, y0+4, y1, y_buffer, y_stride);
911
912 bmi = &mi->bmi[2];
913
914 x1 = x0 +12 + (mv->col >> 3);
915 y1 = y0 + 4 + (mv->row >> 3);
916
917 constrain_line (x0+12, &x1, y0+4, &y1, width, height);
918 vp8_blit_line (x0+12, x1, y0+4, y1, y_buffer, y_stride);
919
920 bmi = &mi->bmi[8];
921
922 x1 = x0 + 4 + (mv->col >> 3);
923 y1 = y0 +12 + (mv->row >> 3);
924
925 constrain_line (x0+4, &x1, y0+12, &y1, width, height);
926 vp8_blit_line (x0+4, x1, y0+12, y1, y_buffer, y_stride);
927
928 bmi = &mi->bmi[10];
929
930 x1 = x0 +12 + (mv->col >> 3);
931 y1 = y0 +12 + (mv->row >> 3);
932
933 constrain_line (x0+12, &x1, y0+12, &y1, width, height);
934 vp8_blit_line (x0+12, x1, y0+12, y1, y_buffer, y_stride);
935 break;
936 }
937 default :
938 {
939 B_MODE_INFO *bmi = mi->bmi;
940 int bx0, by0;
941
942 for (by0 = y0; by0 < (y0+16); by0 += 4)
943 {
944 for (bx0 = x0; bx0 < (x0+16); bx0 += 4)
945 {
946 MV *mv = &bmi->mv.as_mv;
947
948 x1 = bx0 + 2 + (mv->col >> 3);
949 y1 = by0 + 2 + (mv->row >> 3);
950
951 constrain_line (bx0+2, &x1, by0+2, &y1, width, height);
952 vp8_blit_line (bx0+2, x1, by0+2, y1, y_buffer, y_stride);
953
954 bmi++;
955 }
956 }
957 }
958 }
959 }
960 else if (mi->mbmi.mode >= NEARESTMV)
961 {
962 MV *mv = &mi->mbmi.mv.as_mv;
963 const int lx0 = x0 + 8;
964 const int ly0 = y0 + 8;
965
966 x1 = lx0 + (mv->col >> 3);
967 y1 = ly0 + (mv->row >> 3);
968
969 if (x1 != lx0 && y1 != ly0)
970 {
971 constrain_line (lx0, &x1, ly0-1, &y1, width, height);
972 vp8_blit_line (lx0, x1, ly0-1, y1, y_buffer, y_stride);
973
974 constrain_line (lx0, &x1, ly0+1, &y1, width, height);
975 vp8_blit_line (lx0, x1, ly0+1, y1, y_buffer, y_stride);
976 }
977 else
978 vp8_blit_line (lx0, x1, ly0, y1, y_buffer, y_stride);
979 }
980
981 mi++;
982 }
983 mi++;
984 }
985 }
986
987 /* Color in block modes */
988 if ((flags & VP8D_DEBUG_CLR_BLK_MODES)
989 && (ppflags->display_mb_modes_flag || ppflags->display_b_modes_flag))
990 {
991 int y, x;
992 YV12_BUFFER_CONFIG *post = &oci->post_proc_buffer;
993 int width = post->y_width;
994 int height = post->y_height;
995 unsigned char *y_ptr = oci->post_proc_buffer.y_buffer;
996 unsigned char *u_ptr = oci->post_proc_buffer.u_buffer;
997 unsigned char *v_ptr = oci->post_proc_buffer.v_buffer;
998 int y_stride = oci->post_proc_buffer.y_stride;
999 MODE_INFO *mi = oci->mi;
1000
1001 for (y = 0; y < height; y += 16)
1002 {
1003 for (x = 0; x < width; x += 16)
1004 {
1005 int Y = 0, U = 0, V = 0;
1006
1007 if (mi->mbmi.mode == B_PRED &&
1008 ((ppflags->display_mb_modes_flag & B_PRED) || ppflags->display_b_modes_flag))
1009 {
1010 int by, bx;
1011 unsigned char *yl, *ul, *vl;
1012 B_MODE_INFO *bmi = mi->bmi;
1013
1014 yl = y_ptr + x;
1015 ul = u_ptr + (x>>1);
1016 vl = v_ptr + (x>>1);
1017
1018 for (by = 0; by < 16; by += 4)
1019 {
1020 for (bx = 0; bx < 16; bx += 4)
1021 {
1022 if ((ppflags->display_b_modes_flag & (1<<mi->mbmi.mode))
1023 || (ppflags->display_mb_modes_flag & B_PRED))
1024 {
1025 Y = B_PREDICTION_MODE_colors[bmi->mode][0];
1026 U = B_PREDICTION_MODE_colors[bmi->mode][1];
1027 V = B_PREDICTION_MODE_colors[bmi->mode][2];
1028
1029 POSTPROC_INVOKE(RTCD_VTABLE(oci), blend_b)
1030 (yl+bx, ul+(bx>>1), vl+(bx>>1), Y, U, V, 0xc000, y_stride);
1031 }
1032 bmi++;
1033 }
1034
1035 yl += y_stride*4;
1036 ul += y_stride*1;
1037 vl += y_stride*1;
1038 }
1039 }
1040 else if (ppflags->display_mb_modes_flag & (1<<mi->mbmi.mode))
1041 {
1042 Y = MB_PREDICTION_MODE_colors[mi->mbmi.mode][0];
1043 U = MB_PREDICTION_MODE_colors[mi->mbmi.mode][1];
1044 V = MB_PREDICTION_MODE_colors[mi->mbmi.mode][2];
1045
1046 POSTPROC_INVOKE(RTCD_VTABLE(oci), blend_mb_inner)
1047 (y_ptr+x, u_ptr+(x>>1), v_ptr+(x>>1), Y, U, V, 0xc000, y_stride);
1048 }
1049
1050 mi++;
1051 }
1052 y_ptr += y_stride*16;
1053 u_ptr += y_stride*4;
1054 v_ptr += y_stride*4;
1055
1056 mi++;
1057 }
1058 }
1059
1060 /* Color in frame reference blocks */
1061 if ((flags & VP8D_DEBUG_CLR_FRM_REF_BLKS) && ppflags->display_ref_frame_flag)
1062 {
1063 int y, x;
1064 YV12_BUFFER_CONFIG *post = &oci->post_proc_buffer;
1065 int width = post->y_width;
1066 int height = post->y_height;
1067 unsigned char *y_ptr = oci->post_proc_buffer.y_buffer;
1068 unsigned char *u_ptr = oci->post_proc_buffer.u_buffer;
1069 unsigned char *v_ptr = oci->post_proc_buffer.v_buffer;
1070 int y_stride = oci->post_proc_buffer.y_stride;
1071 MODE_INFO *mi = oci->mi;
1072
1073 for (y = 0; y < height; y += 16)
1074 {
1075 for (x = 0; x < width; x +=16)
1076 {
1077 int Y = 0, U = 0, V = 0;
1078
1079 if (ppflags->display_ref_frame_flag & (1<<mi->mbmi.ref_frame))
1080 {
1081 Y = MV_REFERENCE_FRAME_colors[mi->mbmi.ref_frame][0];
1082 U = MV_REFERENCE_FRAME_colors[mi->mbmi.ref_frame][1];
1083 V = MV_REFERENCE_FRAME_colors[mi->mbmi.ref_frame][2];
1084
1085 POSTPROC_INVOKE(RTCD_VTABLE(oci), blend_mb_outer)
1086 (y_ptr+x, u_ptr+(x>>1), v_ptr+(x>>1), Y, U, V, 0xc000, y_stride);
1087 }
1088
1089 mi++;
1090 }
1091 y_ptr += y_stride*16;
1092 u_ptr += y_stride*4;
1093 v_ptr += y_stride*4;
1094
1095 mi++;
1096 }
1097 }
1098 #endif
1099
1100 *dest = oci->post_proc_buffer;
1101
1102 /* handle problem with extending borders */
1103 dest->y_width = oci->Width;
1104 dest->y_height = oci->Height;
1105 dest->uv_height = dest->y_height / 2;
1106 return 0;
1107 }
mirror for libvpx