libmpcodecs/vf_hue.c

   1 /*
   2  * This file is part of MPlayer.
   3  *
   4  * MPlayer is free software; you can redistribute it and/or modify
   5  * it under the terms of the GNU General Public License as published by
   6  * the Free Software Foundation; either version 2 of the License, or
   7  * (at your option) any later version.
   8  *
   9  * MPlayer is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  * GNU General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License along
  15  * with MPlayer; if not, write to the Free Software Foundation, Inc.,
  16  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  17  */
  18
  19 #include <stdio.h>
  20 #include <stdlib.h>
  21 #include <string.h>
  22 #include <inttypes.h>
  23 #include <math.h>
  24
  25 #include "config.h"
  26 #include "mp_msg.h"
  27 #include "cpudetect.h"
  28
  29 #include "img_format.h"
  30 #include "mp_image.h"
  31 #include "vf.h"
  32
  33 #include "libvo/video_out.h"
  34
  35 #include "m_option.h"
  36 #include "m_struct.h"
  37
  38 static struct vf_priv_s {
  39         uint8_t *buf[2];
  40         float hue;
  41         float saturation;
  42 } const vf_priv_dflt = {
  43   {NULL, NULL},
  44   0.0,
  45   1.0,
  46 };
  47
  48 static void process_C(uint8_t *udst, uint8_t *vdst, uint8_t *usrc, uint8_t *vsrc, int dststride, int srcstride,
  49                     int w, int h, float hue, float sat)
  50 {
  51         int i;
  52         const int s= rint(sin(hue) * (1<<16) * sat);
  53         const int c= rint(cos(hue) * (1<<16) * sat);
  54
  55         while (h--) {
  56                 for (i = 0; i<w; i++)
  57                 {
  58                         const int u= usrc[i] - 128;
  59                         const int v= vsrc[i] - 128;
  60                         int new_u= (c*u - s*v + (1<<15) + (128<<16))>>16;
  61                         int new_v= (s*u + c*v + (1<<15) + (128<<16))>>16;
  62                         if(new_u & 768) new_u= (-new_u)>>31;
  63                         if(new_v & 768) new_v= (-new_v)>>31;
  64                         udst[i]= new_u;
  65                         vdst[i]= new_v;
  66                 }
  67                 usrc += srcstride;
  68                 vsrc += srcstride;
  69                 udst += dststride;
  70                 vdst += dststride;
  71         }
  72 }
  73
  74 static void (*process)(uint8_t *udst, uint8_t *vdst, uint8_t *usrc, uint8_t *vsrc, int dststride, int srcstride,
  75                     int w, int h, float hue, float sat);
  76
  77 /* FIXME: add packed yuv version of process */
  78
  79 static int put_image(struct vf_instance *vf, mp_image_t *mpi, double pts)
  80 {
  81         mp_image_t *dmpi;
  82
  83         dmpi=vf_get_image(vf->next, mpi->imgfmt,
  84                           MP_IMGTYPE_EXPORT, 0,
  85                           mpi->w, mpi->h);
  86
  87         dmpi->planes[0] = mpi->planes[0];
  88         dmpi->stride[0] = mpi->stride[0];
  89         dmpi->stride[1] = mpi->stride[1];
  90         dmpi->stride[2] = mpi->stride[2];
  91
  92         if (!vf->priv->buf[0]){
  93                 vf->priv->buf[0] = malloc(mpi->stride[1]*mpi->h >> mpi->chroma_y_shift);
  94                 vf->priv->buf[1] = malloc(mpi->stride[2]*mpi->h >> mpi->chroma_y_shift);
  95         }
  96
  97         if (vf->priv->hue == 0 && vf->priv->saturation == 1){
  98                 dmpi->planes[1] = mpi->planes[1];
  99                 dmpi->planes[2] = mpi->planes[2];
 100         }else {
 101                 dmpi->planes[1] = vf->priv->buf[0];
 102                 dmpi->planes[2] = vf->priv->buf[1];
 103                 process(dmpi->planes[1], dmpi->planes[2],
 104                         mpi->planes[1], mpi->planes[2],
 105                         dmpi->stride[1],mpi->stride[1],
 106                         mpi->w>> mpi->chroma_x_shift, mpi->h>> mpi->chroma_y_shift,
 107                         vf->priv->hue, vf->priv->saturation);
 108         }
 109
 110         return vf_next_put_image(vf,dmpi, pts);
 111 }
 112
 113 static int control(struct vf_instance *vf, int request, void* data)
 114 {
 115         vf_equalizer_t *eq;
 116
 117         switch (request) {
 118         case VFCTRL_SET_EQUALIZER:
 119                 eq = data;
 120                 if (!strcmp(eq->item,"hue")) {
 121                         vf->priv->hue = eq->value * M_PI / 100;
 122                         return CONTROL_TRUE;
 123                 } else if (!strcmp(eq->item,"saturation")) {
 124                         vf->priv->saturation = (eq->value + 100)/100.0;
 125                         return CONTROL_TRUE;
 126                 }
 127                 break;
 128         case VFCTRL_GET_EQUALIZER:
 129                 eq = data;
 130                 if (!strcmp(eq->item,"hue")) {
 131                         eq->value = rint(vf->priv->hue *100 / M_PI);
 132                         return CONTROL_TRUE;
 133                 }else if (!strcmp(eq->item,"saturation")) {
 134                         eq->value = rint(vf->priv->saturation*100 - 100);
 135                         return CONTROL_TRUE;
 136                 }
 137                 break;
 138         }
 139         return vf_next_control(vf, request, data);
 140 }
 141
 142 static int query_format(struct vf_instance *vf, unsigned int fmt)
 143 {
 144         switch (fmt) {
 145         case IMGFMT_YVU9:
 146         case IMGFMT_IF09:
 147         case IMGFMT_YV12:
 148         case IMGFMT_I420:
 149         case IMGFMT_IYUV:
 150         case IMGFMT_CLPL:
 151         case IMGFMT_444P:
 152         case IMGFMT_422P:
 153         case IMGFMT_411P:
 154                 return vf_next_query_format(vf, fmt);
 155         }
 156         return 0;
 157 }
 158
 159 static void uninit(struct vf_instance *vf)
 160 {
 161         if (vf->priv->buf[0]) free(vf->priv->buf[0]);
 162         if (vf->priv->buf[1]) free(vf->priv->buf[1]);
 163         free(vf->priv);
 164 }
 165
 166 static int vf_open(vf_instance_t *vf, char *args)
 167 {
 168         vf->control=control;
 169         vf->query_format=query_format;
 170         vf->put_image=put_image;
 171         vf->uninit=uninit;
 172
 173         vf->priv->hue *= M_PI / 180.0;
 174
 175         process = process_C;
 176         return 1;
 177 }
 178
 179 #define ST_OFF(f) M_ST_OFF(struct vf_priv_s,f)
 180 static const m_option_t vf_opts_fields[] = {
 181   {"hue", ST_OFF(hue), CONF_TYPE_FLOAT, M_OPT_RANGE,-180.0 ,180.0, NULL},
 182   {"saturation", ST_OFF(saturation), CONF_TYPE_FLOAT, M_OPT_RANGE,-10.0 ,10.0, NULL},
 183   { NULL, NULL, 0, 0, 0, 0,  NULL }
 184 };
 185
 186 static const m_struct_t vf_opts = {
 187   "hue",
 188   sizeof(struct vf_priv_s),
 189   &vf_priv_dflt,
 190   vf_opts_fields
 191 };
 192
 193 const vf_info_t vf_info_hue = {
 194         "hue changer",
 195         "hue",
 196         "Michael Niedermayer",
 197         "",
 198         vf_open,
 199         &vf_opts
 200 };