The Tor Browser / file comparison

comparison: media/libvpx/vp8/common/postproc.c

media/libvpx/vp8/common/postproc.c

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

Mercurial Repository: The Tor Browser

Europalab SCM Repository Server

mercurial