SHARE
TWEET

Dark Shikari

a guest Feb 21st, 2008 3,611 Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  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
Top