Subversion Repositories Kolibri OS

Rev

Go to most recent revision | Blame | Last modification | View Log | RSS feed

  1. /*
  2.  * Software equalizer (brightness, contrast, gamma, saturation)
  3.  *
  4.  * Hampa Hug <hampa@hampa.ch> (original LUT gamma/contrast/brightness filter)
  5.  * Daniel Moreno <comac@comac.darktech.org> (saturation, R/G/B gamma support)
  6.  * Richard Felker (original MMX contrast/brightness code (vf_eq.c))
  7.  * Michael Niedermayer <michalni@gmx.at> (LUT16)
  8.  *
  9.  * This file is part of MPlayer.
  10.  *
  11.  * MPlayer is free software; you can redistribute it and/or modify
  12.  * it under the terms of the GNU General Public License as published by
  13.  * the Free Software Foundation; either version 2 of the License, or
  14.  * (at your option) any later version.
  15.  *
  16.  * MPlayer is distributed in the hope that it will be useful,
  17.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  18.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19.  * GNU General Public License for more details.
  20.  *
  21.  * You should have received a copy of the GNU General Public License along
  22.  * with MPlayer; if not, write to the Free Software Foundation, Inc.,
  23.  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  24.  */
  25.  
  26. #include <stdio.h>
  27. #include <stdlib.h>
  28. #include <string.h>
  29. #include <math.h>
  30. #include <inttypes.h>
  31.  
  32. #include "config.h"
  33. #include "mp_msg.h"
  34. #include "cpudetect.h"
  35.  
  36. #include "img_format.h"
  37. #include "mp_image.h"
  38. #include "vf.h"
  39.  
  40. #define LUT16
  41.  
  42. /* Per channel parameters */
  43. typedef struct eq2_param_t {
  44.   unsigned char lut[256];
  45. #ifdef LUT16
  46.   uint16_t lut16[256*256];
  47. #endif
  48.   int           lut_clean;
  49.  
  50.   void (*adjust) (struct eq2_param_t *par, unsigned char *dst, unsigned char *src,
  51.     unsigned w, unsigned h, unsigned dstride, unsigned sstride);
  52.  
  53.   double        c;
  54.   double        b;
  55.   double        g;
  56.   double        w;
  57. } eq2_param_t;
  58.  
  59. typedef struct vf_priv_s {
  60.   eq2_param_t param[3];
  61.  
  62.   double        contrast;
  63.   double        brightness;
  64.   double        saturation;
  65.  
  66.   double        gamma;
  67.   double        gamma_weight;
  68.   double        rgamma;
  69.   double        ggamma;
  70.   double        bgamma;
  71.  
  72.   unsigned      buf_w[3];
  73.   unsigned      buf_h[3];
  74.   unsigned char *buf[3];
  75. } vf_eq2_t;
  76.  
  77.  
  78. static
  79. void create_lut (eq2_param_t *par)
  80. {
  81.   unsigned i;
  82.   double   g, v;
  83.   double   lw, gw;
  84.  
  85.   g = par->g;
  86.   gw = par->w;
  87.   lw = 1.0 - gw;
  88.  
  89.   if ((g < 0.001) || (g > 1000.0)) {
  90.     g = 1.0;
  91.   }
  92.  
  93.   g = 1.0 / g;
  94.  
  95.   for (i = 0; i < 256; i++) {
  96.     v = (double) i / 255.0;
  97.     v = par->c * (v - 0.5) + 0.5 + par->b;
  98.  
  99.     if (v <= 0.0) {
  100.       par->lut[i] = 0;
  101.     }
  102.     else {
  103.       v = v*lw + pow(v, g)*gw;
  104.  
  105.       if (v >= 1.0) {
  106.         par->lut[i] = 255;
  107.       }
  108.       else {
  109.         par->lut[i] = (unsigned char) (256.0 * v);
  110.       }
  111.     }
  112.   }
  113.  
  114. #ifdef LUT16
  115.   for(i=0; i<256*256; i++){
  116.     par->lut16[i]= par->lut[i&0xFF] + (par->lut[i>>8]<<8);
  117.   }
  118. #endif
  119.  
  120.   par->lut_clean = 1;
  121. }
  122.  
  123. #if HAVE_MMX
  124. static
  125. void affine_1d_MMX (eq2_param_t *par, unsigned char *dst, unsigned char *src,
  126.   unsigned w, unsigned h, unsigned dstride, unsigned sstride)
  127. {
  128.   unsigned i;
  129.   int      contrast, brightness;
  130.   unsigned dstep, sstep;
  131.   int      pel;
  132.   short    brvec[4];
  133.   short    contvec[4];
  134.  
  135. //  printf("\nmmx: src=%p dst=%p w=%d h=%d ds=%d ss=%d\n",src,dst,w,h,dstride,sstride);
  136.  
  137.   contrast = (int) (par->c * 256 * 16);
  138.   brightness = ((int) (100.0 * par->b + 100.0) * 511) / 200 - 128 - contrast / 32;
  139.  
  140.   brvec[0] = brvec[1] = brvec[2] = brvec[3] = brightness;
  141.   contvec[0] = contvec[1] = contvec[2] = contvec[3] = contrast;
  142.  
  143.   sstep = sstride - w;
  144.   dstep = dstride - w;
  145.  
  146.   while (h-- > 0) {
  147.     __asm__ volatile (
  148.       "movq (%5), %%mm3 \n\t"
  149.       "movq (%6), %%mm4 \n\t"
  150.       "pxor %%mm0, %%mm0 \n\t"
  151.       "movl %4, %%eax\n\t"
  152.       ASMALIGN(4)
  153.       "1: \n\t"
  154.       "movq (%0), %%mm1 \n\t"
  155.       "movq (%0), %%mm2 \n\t"
  156.       "punpcklbw %%mm0, %%mm1 \n\t"
  157.       "punpckhbw %%mm0, %%mm2 \n\t"
  158.       "psllw $4, %%mm1 \n\t"
  159.       "psllw $4, %%mm2 \n\t"
  160.       "pmulhw %%mm4, %%mm1 \n\t"
  161.       "pmulhw %%mm4, %%mm2 \n\t"
  162.       "paddw %%mm3, %%mm1 \n\t"
  163.       "paddw %%mm3, %%mm2 \n\t"
  164.       "packuswb %%mm2, %%mm1 \n\t"
  165.       "add $8, %0 \n\t"
  166.       "movq %%mm1, (%1) \n\t"
  167.       "add $8, %1 \n\t"
  168.       "decl %%eax \n\t"
  169.       "jnz 1b \n\t"
  170.       : "=r" (src), "=r" (dst)
  171.       : "0" (src), "1" (dst), "r" (w >> 3), "r" (brvec), "r" (contvec)
  172.       : "%eax"
  173.     );
  174.  
  175.     for (i = w & 7; i > 0; i--) {
  176.       pel = ((*src++ * contrast) >> 12) + brightness;
  177.       if (pel & 768) {
  178.         pel = (-pel) >> 31;
  179.       }
  180.       *dst++ = pel;
  181.     }
  182.  
  183.     src += sstep;
  184.     dst += dstep;
  185.   }
  186.  
  187.   __asm__ volatile ( "emms \n\t" ::: "memory" );
  188. }
  189. #endif
  190.  
  191. static
  192. void apply_lut (eq2_param_t *par, unsigned char *dst, unsigned char *src,
  193.   unsigned w, unsigned h, unsigned dstride, unsigned sstride)
  194. {
  195.   unsigned      i, j, w2;
  196.   unsigned char *lut;
  197.   uint16_t *lut16;
  198.  
  199.   if (!par->lut_clean) {
  200.     create_lut (par);
  201.   }
  202.  
  203.   lut = par->lut;
  204. #ifdef LUT16
  205.   lut16 = par->lut16;
  206.   w2= (w>>3)<<2;
  207.   for (j = 0; j < h; j++) {
  208.     uint16_t *src16= (uint16_t*)src;
  209.     uint16_t *dst16= (uint16_t*)dst;
  210.     for (i = 0; i < w2; i+=4) {
  211.       dst16[i+0] = lut16[src16[i+0]];
  212.       dst16[i+1] = lut16[src16[i+1]];
  213.       dst16[i+2] = lut16[src16[i+2]];
  214.       dst16[i+3] = lut16[src16[i+3]];
  215.     }
  216.     i <<= 1;
  217. #else
  218.   w2= (w>>3)<<3;
  219.   for (j = 0; j < h; j++) {
  220.     for (i = 0; i < w2; i+=8) {
  221.       dst[i+0] = lut[src[i+0]];
  222.       dst[i+1] = lut[src[i+1]];
  223.       dst[i+2] = lut[src[i+2]];
  224.       dst[i+3] = lut[src[i+3]];
  225.       dst[i+4] = lut[src[i+4]];
  226.       dst[i+5] = lut[src[i+5]];
  227.       dst[i+6] = lut[src[i+6]];
  228.       dst[i+7] = lut[src[i+7]];
  229.     }
  230. #endif
  231.     for (; i < w; i++) {
  232.       dst[i] = lut[src[i]];
  233.     }
  234.  
  235.     src += sstride;
  236.     dst += dstride;
  237.   }
  238. }
  239.  
  240. static
  241. int put_image (vf_instance_t *vf, mp_image_t *src, double pts)
  242. {
  243.   unsigned      i;
  244.   vf_eq2_t      *eq2;
  245.   mp_image_t    *dst;
  246.   unsigned long img_n,img_c;
  247.  
  248.   eq2 = vf->priv;
  249.  
  250.   if ((eq2->buf_w[0] != src->w) || (eq2->buf_h[0] != src->h)) {
  251.     eq2->buf_w[0] = src->w;
  252.     eq2->buf_h[0] = src->h;
  253.       eq2->buf_w[1] = eq2->buf_w[2] = src->w >> src->chroma_x_shift;
  254.       eq2->buf_h[1] = eq2->buf_h[2] = src->h >> src->chroma_y_shift;
  255.     img_n = eq2->buf_w[0]*eq2->buf_h[0];
  256.     if(src->num_planes>1){
  257.       img_c = eq2->buf_w[1]*eq2->buf_h[1];
  258.       eq2->buf[0] = realloc (eq2->buf[0], img_n + 2*img_c);
  259.       eq2->buf[1] = eq2->buf[0] + img_n;
  260.       eq2->buf[2] = eq2->buf[1] + img_c;
  261.     } else
  262.       eq2->buf[0] = realloc (eq2->buf[0], img_n);
  263.   }
  264.  
  265.   dst = ff_vf_get_image (vf->next, src->imgfmt, MP_IMGTYPE_EXPORT, 0, src->w, src->h);
  266.  
  267.   for (i = 0; i < ((src->num_planes>1)?3:1); i++) {
  268.     if (eq2->param[i].adjust != NULL) {
  269.       dst->planes[i] = eq2->buf[i];
  270.       dst->stride[i] = eq2->buf_w[i];
  271.  
  272.       eq2->param[i].adjust (&eq2->param[i], dst->planes[i], src->planes[i],
  273.         eq2->buf_w[i], eq2->buf_h[i], dst->stride[i], src->stride[i]);
  274.     }
  275.     else {
  276.       dst->planes[i] = src->planes[i];
  277.       dst->stride[i] = src->stride[i];
  278.     }
  279.   }
  280.  
  281.   return ff_vf_next_put_image (vf, dst, pts);
  282. }
  283.  
  284. static
  285. void check_values (eq2_param_t *par)
  286. {
  287.   /* yuck! floating point comparisons... */
  288.  
  289.   if ((par->c == 1.0) && (par->b == 0.0) && (par->g == 1.0)) {
  290.     par->adjust = NULL;
  291.   }
  292. #if HAVE_MMX
  293.   else if (par->g == 1.0 && ff_gCpuCaps.hasMMX) {
  294.     par->adjust = &affine_1d_MMX;
  295.   }
  296. #endif
  297.   else {
  298.     par->adjust = &apply_lut;
  299.   }
  300. }
  301.  
  302. static
  303. void print_values (vf_eq2_t *eq2)
  304. {
  305.   ff_mp_msg (MSGT_VFILTER, MSGL_V, "vf_eq2: c=%.2f b=%.2f g=%.4f s=%.2f \n",
  306.     eq2->contrast, eq2->brightness, eq2->gamma, eq2->saturation
  307.   );
  308. }
  309.  
  310. static
  311. void set_contrast (vf_eq2_t *eq2, double c)
  312. {
  313.   eq2->contrast = c;
  314.   eq2->param[0].c = c;
  315.   eq2->param[0].lut_clean = 0;
  316.   check_values (&eq2->param[0]);
  317.   print_values (eq2);
  318. }
  319.  
  320. static
  321. void set_brightness (vf_eq2_t *eq2, double b)
  322. {
  323.   eq2->brightness = b;
  324.   eq2->param[0].b = b;
  325.   eq2->param[0].lut_clean = 0;
  326.   check_values (&eq2->param[0]);
  327.   print_values (eq2);
  328. }
  329.  
  330. static
  331. void set_gamma (vf_eq2_t *eq2, double g)
  332. {
  333.   eq2->gamma = g;
  334.  
  335.   eq2->param[0].g = eq2->gamma * eq2->ggamma;
  336.   eq2->param[1].g = sqrt (eq2->bgamma / eq2->ggamma);
  337.   eq2->param[2].g = sqrt (eq2->rgamma / eq2->ggamma);
  338.   eq2->param[0].w = eq2->param[1].w = eq2->param[2].w = eq2->gamma_weight;
  339.  
  340.   eq2->param[0].lut_clean = 0;
  341.   eq2->param[1].lut_clean = 0;
  342.   eq2->param[2].lut_clean = 0;
  343.  
  344.   check_values (&eq2->param[0]);
  345.   check_values (&eq2->param[1]);
  346.   check_values (&eq2->param[2]);
  347.  
  348.   print_values (eq2);
  349. }
  350.  
  351. static
  352. void set_saturation (vf_eq2_t *eq2, double s)
  353. {
  354.   eq2->saturation = s;
  355.  
  356.   eq2->param[1].c = s;
  357.   eq2->param[2].c = s;
  358.  
  359.   eq2->param[1].lut_clean = 0;
  360.   eq2->param[2].lut_clean = 0;
  361.  
  362.   check_values (&eq2->param[1]);
  363.   check_values (&eq2->param[2]);
  364.  
  365.   print_values (eq2);
  366. }
  367.  
  368. static
  369. int control (vf_instance_t *vf, int request, void *data)
  370. {
  371.   vf_equalizer_t *eq;
  372.  
  373.   switch (request) {
  374.     case VFCTRL_SET_EQUALIZER:
  375.       eq = (vf_equalizer_t *) data;
  376.  
  377.       if (strcmp (eq->item, "gamma") == 0) {
  378.         set_gamma (vf->priv, exp (log (8.0) * eq->value / 100.0));
  379.         return CONTROL_TRUE;
  380.       }
  381.       else if (strcmp (eq->item, "contrast") == 0) {
  382.         set_contrast (vf->priv, (1.0 / 100.0) * (eq->value + 100));
  383.         return CONTROL_TRUE;
  384.       }
  385.       else if (strcmp (eq->item, "brightness") == 0) {
  386.         set_brightness (vf->priv, (1.0 / 100.0) * eq->value);
  387.         return CONTROL_TRUE;
  388.       }
  389.       else if (strcmp (eq->item, "saturation") == 0) {
  390.         set_saturation (vf->priv, (double) (eq->value + 100) / 100.0);
  391.         return CONTROL_TRUE;
  392.       }
  393.       break;
  394.  
  395.     case VFCTRL_GET_EQUALIZER:
  396.       eq = (vf_equalizer_t *) data;
  397.       if (strcmp (eq->item, "gamma") == 0) {
  398.         eq->value = (int) (100.0 * log (vf->priv->gamma) / log (8.0));
  399.         return CONTROL_TRUE;
  400.       }
  401.       else if (strcmp (eq->item, "contrast") == 0) {
  402.         eq->value = (int) (100.0 * vf->priv->contrast) - 100;
  403.         return CONTROL_TRUE;
  404.       }
  405.       else if (strcmp (eq->item, "brightness") == 0) {
  406.         eq->value = (int) (100.0 * vf->priv->brightness);
  407.         return CONTROL_TRUE;
  408.       }
  409.       else if (strcmp (eq->item, "saturation") == 0) {
  410.         eq->value = (int) (100.0 * vf->priv->saturation) - 100;
  411.         return CONTROL_TRUE;
  412.       }
  413.       break;
  414.   }
  415.  
  416.   return ff_vf_next_control (vf, request, data);
  417. }
  418.  
  419. static
  420. int query_format (vf_instance_t *vf, unsigned fmt)
  421. {
  422.   switch (fmt) {
  423.     case IMGFMT_YVU9:
  424.     case IMGFMT_IF09:
  425.     case IMGFMT_YV12:
  426.     case IMGFMT_I420:
  427.     case IMGFMT_IYUV:
  428.     case IMGFMT_Y800:
  429.     case IMGFMT_Y8:
  430.     case IMGFMT_444P:
  431.     case IMGFMT_422P:
  432.     case IMGFMT_411P:
  433.       return ff_vf_next_query_format (vf, fmt);
  434.   }
  435.  
  436.   return 0;
  437. }
  438.  
  439. static
  440. void uninit (vf_instance_t *vf)
  441. {
  442.   if (vf->priv != NULL) {
  443.     free (vf->priv->buf[0]);
  444.     free (vf->priv);
  445.   }
  446. }
  447.  
  448. static
  449. int vf_open(vf_instance_t *vf, char *args)
  450. {
  451.   unsigned i;
  452.   vf_eq2_t *eq2;
  453.   double   par[8];
  454.  
  455.   vf->control = control;
  456.   vf->query_format = query_format;
  457.   vf->put_image = put_image;
  458.   vf->uninit = uninit;
  459.  
  460.   vf->priv = malloc (sizeof (vf_eq2_t));
  461.   eq2 = vf->priv;
  462.  
  463.   for (i = 0; i < 3; i++) {
  464.     eq2->buf[i] = NULL;
  465.     eq2->buf_w[i] = 0;
  466.     eq2->buf_h[i] = 0;
  467.  
  468.     eq2->param[i].adjust = NULL;
  469.     eq2->param[i].c = 1.0;
  470.     eq2->param[i].b = 0.0;
  471.     eq2->param[i].g = 1.0;
  472.     eq2->param[i].lut_clean = 0;
  473.   }
  474.  
  475.   eq2->contrast = 1.0;
  476.   eq2->brightness = 0.0;
  477.   eq2->saturation = 1.0;
  478.  
  479.   eq2->gamma = 1.0;
  480.   eq2->gamma_weight = 1.0;
  481.   eq2->rgamma = 1.0;
  482.   eq2->ggamma = 1.0;
  483.   eq2->bgamma = 1.0;
  484.  
  485.   if (args != NULL) {
  486.     par[0] = 1.0;
  487.     par[1] = 1.0;
  488.     par[2] = 0.0;
  489.     par[3] = 1.0;
  490.     par[4] = 1.0;
  491.     par[5] = 1.0;
  492.     par[6] = 1.0;
  493.     par[7] = 1.0;
  494.     sscanf (args, "%lf:%lf:%lf:%lf:%lf:%lf:%lf:%lf",
  495.       par, par + 1, par + 2, par + 3, par + 4, par + 5, par + 6, par + 7
  496.     );
  497.  
  498.     eq2->rgamma = par[4];
  499.     eq2->ggamma = par[5];
  500.     eq2->bgamma = par[6];
  501.     eq2->gamma_weight = par[7];
  502.  
  503.     set_gamma (eq2, par[0]);
  504.     set_contrast (eq2, par[1]);
  505.     set_brightness (eq2, par[2]);
  506.     set_saturation (eq2, par[3]);
  507.   }
  508.  
  509.   return 1;
  510. }
  511.  
  512. const vf_info_t ff_vf_info_eq2 = {
  513.   "Software equalizer",
  514.   "eq2",
  515.   "Hampa Hug, Daniel Moreno, Richard Felker",
  516.   "",
  517.   &vf_open,
  518.   NULL
  519. };
  520.