libmpcodecs/vf_eq.c

   1 #include <stdio.h>
   2 #include <stdlib.h>
   3 #include <string.h>
   4 #include <inttypes.h>
   5
   6 #include "config.h"
   7 #include "mp_msg.h"
   8 #include "cpudetect.h"
   9 #include "asmalign.h"
  10
  11 #include "img_format.h"
  12 #include "mp_image.h"
  13 #include "vf.h"
  14
  15 #include "libvo/video_out.h"
  16 #include "libvo/fastmemcpy.h"
  17 #include "postproc/rgb2rgb.h"
  18
  19 #include "m_option.h"
  20 #include "m_struct.h"
  21
  22 static struct vf_priv_s {
  23         unsigned char *buf;
  24         int brightness;
  25         int contrast;
  26 } vf_priv_dflt = {
  27   NULL,
  28   0,
  29   0
  30 };
  31
  32 #ifdef HAVE_MMX
  33 static void process_MMX(unsigned char *dest, int dstride, unsigned char *src, int sstride,
  34                     int w, int h, int brightness, int contrast)
  35 {
  36         int i;
  37         int pel;
  38         int dstep = dstride-w;
  39         int sstep = sstride-w;
  40         short brvec[4];
  41         short contvec[4];
  42
  43         contrast = ((contrast+100)*256*16)/100;
  44         brightness = ((brightness+100)*511)/200-128 - contrast/32;
  45
  46         brvec[0] = brvec[1] = brvec[2] = brvec[3] = brightness;
  47         contvec[0] = contvec[1] = contvec[2] = contvec[3] = contrast;
  48
  49         while (h--) {
  50                 asm volatile (
  51                         "movq (%5), %%mm3 \n\t"
  52                         "movq (%6), %%mm4 \n\t"
  53                         "pxor %%mm0, %%mm0 \n\t"
  54                         "movl %4, %%eax\n\t"
  55                        ASMALIGN16
  56                         "1: \n\t"
  57                         "movq (%0), %%mm1 \n\t"
  58                         "movq (%0), %%mm2 \n\t"
  59                         "punpcklbw %%mm0, %%mm1 \n\t"
  60                         "punpckhbw %%mm0, %%mm2 \n\t"
  61                         "psllw $4, %%mm1 \n\t"
  62                         "psllw $4, %%mm2 \n\t"
  63                         "pmulhw %%mm4, %%mm1 \n\t"
  64                         "pmulhw %%mm4, %%mm2 \n\t"
  65                         "paddw %%mm3, %%mm1 \n\t"
  66                         "paddw %%mm3, %%mm2 \n\t"
  67                         "packuswb %%mm2, %%mm1 \n\t"
  68                         "add $8, %0 \n\t"
  69                         "movq %%mm1, (%1) \n\t"
  70                         "add $8, %1 \n\t"
  71                         "decl %%eax \n\t"
  72                         "jnz 1b \n\t"
  73                         : "=r" (src), "=r" (dest)
  74                         : "0" (src), "1" (dest), "r" (w>>3), "r" (brvec), "r" (contvec)
  75                         : "%eax"
  76                 );
  77
  78                 for (i = w&7; i; i--)
  79                 {
  80                         pel = ((*src++* contrast)>>12) + brightness;
  81                         if(pel&768) pel = (-pel)>>31;
  82                         *dest++ = pel;
  83                 }
  84
  85                 src += sstep;
  86                 dest += dstep;
  87         }
  88         asm volatile ( "emms \n\t" ::: "memory" );
  89 }
  90 #endif
  91
  92 static void process_C(unsigned char *dest, int dstride, unsigned char *src, int sstride,
  93                     int w, int h, int brightness, int contrast)
  94 {
  95         int i;
  96         int pel;
  97         int dstep = dstride-w;
  98         int sstep = sstride-w;
  99
 100         contrast = ((contrast+100)*256*256)/100;
 101         brightness = ((brightness+100)*511)/200-128 - contrast/512;
 102
 103         while (h--) {
 104                 for (i = w; i; i--)
 105                 {
 106                         pel = ((*src++* contrast)>>16) + brightness;
 107                         if(pel&768) pel = (-pel)>>31;
 108                         *dest++ = pel;
 109                 }
 110                 src += sstep;
 111                 dest += dstep;
 112         }
 113 }
 114
 115 static void (*process)(unsigned char *dest, int dstride, unsigned char *src, int sstride,
 116                        int w, int h, int brightness, int contrast);
 117
 118 /* FIXME: add packed yuv version of process */
 119
 120 static int put_image(struct vf_instance_s* vf, mp_image_t *mpi, double pts)
 121 {
 122         mp_image_t *dmpi;
 123
 124         dmpi=vf_get_image(vf->next, mpi->imgfmt,
 125                           MP_IMGTYPE_EXPORT, 0,
 126                           mpi->w, mpi->h);
 127
 128         dmpi->stride[0] = mpi->stride[0];
 129         dmpi->planes[1] = mpi->planes[1];
 130         dmpi->planes[2] = mpi->planes[2];
 131         dmpi->stride[1] = mpi->stride[1];
 132         dmpi->stride[2] = mpi->stride[2];
 133
 134         if (!vf->priv->buf) vf->priv->buf = malloc(mpi->stride[0]*mpi->h);
 135
 136         if ((vf->priv->brightness == 0) && (vf->priv->contrast == 0))
 137                 dmpi->planes[0] = mpi->planes[0];
 138         else {
 139                 dmpi->planes[0] = vf->priv->buf;
 140                 process(dmpi->planes[0], dmpi->stride[0],
 141                         mpi->planes[0], mpi->stride[0],
 142                         mpi->w, mpi->h, vf->priv->brightness,
 143                         vf->priv->contrast);
 144         }
 145
 146         return vf_next_put_image(vf,dmpi, pts);
 147 }
 148
 149 static int control(struct vf_instance_s* vf, int request, void* data)
 150 {
 151         vf_equalizer_t *eq;
 152
 153         switch (request) {
 154         case VFCTRL_SET_EQUALIZER:
 155                 eq = data;
 156                 if (!strcmp(eq->item,"brightness")) {
 157                         vf->priv->brightness = eq->value;
 158                         return CONTROL_TRUE;
 159                 }
 160                 else if (!strcmp(eq->item,"contrast")) {
 161                         vf->priv->contrast = eq->value;
 162                         return CONTROL_TRUE;
 163                 }
 164                 break;
 165         case VFCTRL_GET_EQUALIZER:
 166                 eq = data;
 167                 if (!strcmp(eq->item,"brightness")) {
 168                         eq->value = vf->priv->brightness;
 169                         return CONTROL_TRUE;
 170                 }
 171                 else if (!strcmp(eq->item,"contrast")) {
 172                         eq->value = vf->priv->contrast;
 173                         return CONTROL_TRUE;
 174                 }
 175                 break;
 176         }
 177         return vf_next_control(vf, request, data);
 178 }
 179
 180 static int query_format(struct vf_instance_s* vf, unsigned int fmt)
 181 {
 182         switch (fmt) {
 183         case IMGFMT_YVU9:
 184         case IMGFMT_IF09:
 185         case IMGFMT_YV12:
 186         case IMGFMT_I420:
 187         case IMGFMT_IYUV:
 188         case IMGFMT_CLPL:
 189         case IMGFMT_Y800:
 190         case IMGFMT_Y8:
 191         case IMGFMT_NV12:
 192         case IMGFMT_NV21:
 193         case IMGFMT_444P:
 194         case IMGFMT_422P:
 195         case IMGFMT_411P:
 196                 return vf_next_query_format(vf, fmt);
 197         }
 198         return 0;
 199 }
 200
 201 static void uninit(struct vf_instance_s* vf)
 202 {
 203         if (vf->priv->buf) free(vf->priv->buf);
 204         free(vf->priv);
 205 }
 206
 207 static int open(vf_instance_t *vf, char* args)
 208 {
 209         vf->control=control;
 210         vf->query_format=query_format;
 211         vf->put_image=put_image;
 212         vf->uninit=uninit;
 213
 214         if(!vf->priv) {
 215         vf->priv = malloc(sizeof(struct vf_priv_s));
 216         memset(vf->priv, 0, sizeof(struct vf_priv_s));
 217         }
 218         if (args) sscanf(args, "%d:%d", &vf->priv->brightness, &vf->priv->contrast);
 219
 220         process = process_C;
 221 #ifdef HAVE_MMX
 222         if(gCpuCaps.hasMMX) process = process_MMX;
 223 #endif
 224
 225         return 1;
 226 }
 227
 228 #define ST_OFF(f) M_ST_OFF(struct vf_priv_s,f)
 229 static m_option_t vf_opts_fields[] = {
 230   {"brightness", ST_OFF(brightness), CONF_TYPE_INT, M_OPT_RANGE,-100 ,100, NULL},
 231   {"contrast", ST_OFF(contrast), CONF_TYPE_INT, M_OPT_RANGE,-100 ,100, NULL},
 232   { NULL, NULL, 0, 0, 0, 0,  NULL }
 233 };
 234
 235 static m_struct_t vf_opts = {
 236   "eq",
 237   sizeof(struct vf_priv_s),
 238   &vf_priv_dflt,
 239   vf_opts_fields
 240 };
 241
 242 vf_info_t vf_info_eq = {
 243         "soft video equalizer",
 244         "eq",
 245         "Richard Felker",
 246         "",
 247         open,
 248         &vf_opts
 249 };
 250