Need a unique gift idea?
A Pastebin account makes a great Christmas gift
SHARE
TWEET

Dark Shikari

a guest Feb 21st, 2008 3,662 Never
Upgrade to PRO!
ENDING IN00days00hours00mins00secs
 
  1. --- /c/Documents and Settings/Jason/Desktop/plugin_lumimasking.c        2006-05-05 21:37:15.000000000 -0700
  2. +++ ../xvid/src/plugins/plugin_lumimasking.c    2008-02-21 02:16:56.359375000 -0800
  3.  -2,11 +2,11 @@
  4.   *
  5.   *  XVID MPEG-4 VIDEO CODEC
  6.   *  - XviD plugin: performs a lumimasking algorithm on encoded frame  -
  7.   *
  8.   *  Copyright(C) 2002-2003 Peter Ross <pross@xvid.org>
  9. - *               2002      Christoph Lampert <gruel@web.de>
  10. + *                        2002   Christoph Lampert <gruel@web.de>
  11.   *
  12.   *  This program is free software ; you can redistribute it and/or modify
  13.   *  it under the terms of the GNU General Public License as published by
  14.   *  the Free Software Foundation ; either version 2 of the License, or
  15.   *  (at your option) any later version.
  16.  -23,10 +23,12 @@
  17.   * $Id: plugin_lumimasking.c,v 1.6 2006/05/06 04:37:15 syskin Exp $
  18.   *
  19.   ****************************************************************************/
  20.  
  21.  #include <stdlib.h>
  22. +#include <stdio.h>
  23. +#include <math.h>
  24.  
  25.  #include "../xvid.h"
  26.  #include "../global.h"
  27.  #include "../portab.h"
  28.  #include "../utils/emms.h"
  29.  -155,31 +157,31 @@
  30.                                                                          int *out,
  31.                                                                          int num,
  32.                                                                          int min_quant,
  33.                                                                          int max_quant);
  34.  
  35. -static int
  36. -lumi_plg_frame(lumi_data_t *handle, xvid_plg_data_t *data)
  37. +static int lumi_plg_frame(lumi_data_t *handle, xvid_plg_data_t *data)
  38.  {
  39. -       int i, j;
  40. -
  41. -       float global = 0.0f;
  42. +       //Don't apply variance-masking to B-frames.
  43. +    fprintf(stderr,"TEST\n");
  44. +    return 0;
  45. +       if (data->type == XVID_TYPE_BVOP) return 0;
  46.  
  47. -       const float DarkAmpl = 14 / 4;
  48. -       const float BrightAmpl = 10 / 3;
  49. -       float DarkThres = 90;
  50. -       float BrightThres = 200;
  51. +       int i, j;
  52.  
  53. -       const float GlobalDarkThres = 60;
  54. -       const float GlobalBrightThres = 170;
  55. +       /* Arbitrary centerpoint for variance-based AQ.  Roughly the same as used in x264. */
  56. +       float center = 14000;
  57.  
  58. -       if (data->type == XVID_TYPE_BVOP) return 0;
  59. +       /* Arbitrary strength for variance-based AQ. */
  60. +       float strength = 0.2;
  61.  
  62.         /* Do this for all macroblocks individually  */
  63. -       for (j = 0; j < data->mb_height; j++) {
  64. -               for (i = 0; i < data->mb_width; i++) {
  65. -                       int k, l, sum = 0;
  66. +       for (j = 0; j < data->mb_height; j++)
  67. +       {
  68. +               for (i = 0; i < data->mb_width; i++)
  69. +               {
  70. +                       int k, l, sum = 0, sum_of_squares = 0;
  71.                         unsigned char *ptr;
  72.  
  73.                         /* Initialize the current quant value to the frame quant */
  74.                         handle->quant[j*data->mb_width + i] = (float)data->quant;
  75.  
  76.  -187,41 +189,34 @@
  77.  
  78.                         /* Get the MB address */
  79.                         ptr  = data->current.plane[0];
  80.                         ptr += 16*j*data->current.stride[0] + 16*i;
  81.  
  82. -                       /* Accumulate luminance */
  83. +                       /* Accumulate sum and sum of squares over the MB */
  84.                         for (k = 0; k < 16; k++)
  85.                                 for (l = 0; l < 16; l++)
  86. -                                        sum += ptr[k*data->current.stride[0] + l];
  87. +                               {
  88. +                                       int val = ptr[k*data->current.stride[0] + l];
  89. +                                       sum += val;
  90. +                                       sum_of_squares += val * val;
  91. +                               }
  92. +                                        
  93. +                       /* Variance = SSD - SAD^2 / (numpixels) */
  94. +                       int variance = sum_of_squares - sum * sum / 256;
  95.                        
  96. -                       handle->val[j*data->mb_width + i] = (float)sum/256.0f;
  97. -
  98. -                       /* Accumulate the global frame luminance */
  99. -                       global += (float)sum/256.0f;
  100. +                       handle->val[j*data->mb_width + i] = variance;
  101.                 }
  102.         }
  103. -
  104. -       /* Normalize the global luminance accumulator */
  105. -       global /= data->mb_width*data->mb_height;
  106. -
  107. -       DarkThres = DarkThres*global/127.0f;
  108. -       BrightThres = BrightThres*global/127.0f;
  109. -
  110. -
  111. -       /* Apply luminance masking only to frames where the global luminance is
  112. -        * higher than DarkThreshold and lower than Bright Threshold */
  113. -        if ((global < GlobalBrightThres) && (global > GlobalDarkThres)) {
  114. -
  115. -               /* Apply the luminance masking formulas to all MBs */
  116. -               for (i = 0; i < data->mb_height; i++) {
  117. -                       for (j = 0; j < data->mb_width; j++) {
  118. -                               if (handle->val[i*data->mb_width + j] < DarkThres)
  119. -                                       handle->quant[i*data->mb_width + j] *= 1 + DarkAmpl * (DarkThres - handle->val[i*data->mb_width + j]) / DarkThres;
  120. -                               else if (handle->val[i*data->mb_width + j] > BrightThres)
  121. -                                       handle->quant[i*data->mb_width + j] *= 1 + BrightAmpl * (handle->val[i*data->mb_width + j] - BrightThres) / (255 - BrightThres);
  122. -                       }
  123. +    
  124. +       /* Apply the variance masking formula to all MBs */
  125. +       for (i = 0; i < data->mb_height; i++)
  126. +       {
  127. +               for (j = 0; j < data->mb_width; j++)
  128. +               {
  129. +                       float value = handle->val[i*data->mb_width + j];
  130. +                       float qscale_diff = strength * logf(value / center);
  131. +                       handle->quant[i*data->mb_width + j] *= (1.0 + qscale_diff);
  132.                 }
  133.         }
  134.  
  135.          /* Normalize the quantizer field */
  136.          data->quant = normalize_quantizer_field(handle->quant,
  137.  -246,11 +241,11 @@
  138.  
  139.  /*****************************************************************************
  140.   * Helper functions
  141.   ****************************************************************************/
  142.  
  143. -#define RDIFF(a, b)    ((int)(a+0.5)-(int)(b+0.5))
  144. +#define RDIFF(a, b)    ((int)(a+0.5)-(int)(b+0.5))
  145.  
  146.  static int
  147.  normalize_quantizer_field(float *in,
  148.                                                   int *out,
  149.                                                   int num,
RAW Paste Data
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy. OK, I Understand
 
Top