|
11249
|
1 #include <stdio.h>
|
|
|
2 #include <stdlib.h>
|
|
|
3 #include <string.h>
|
|
|
4 #include <inttypes.h>
|
|
|
5 #include <math.h>
|
|
|
6
|
|
17012
|
7 #include "config.h"
|
|
|
8 #include "mp_msg.h"
|
|
|
9 #include "cpudetect.h"
|
|
11249
|
10
|
|
|
11 #include "img_format.h"
|
|
|
12 #include "mp_image.h"
|
|
|
13 #include "vf.h"
|
|
|
14
|
|
17012
|
15 #include "libvo/video_out.h"
|
|
11249
|
16
|
|
|
17 #include "m_option.h"
|
|
|
18 #include "m_struct.h"
|
|
|
19
|
|
|
20 static struct vf_priv_s {
|
|
|
21 uint8_t *buf[2];
|
|
|
22 float hue;
|
|
|
23 float saturation;
|
|
22027
|
24 } const vf_priv_dflt = {
|
|
11249
|
25 {NULL, NULL},
|
|
|
26 0.0,
|
|
|
27 1.0,
|
|
|
28 };
|
|
|
29
|
|
|
30 static void process_C(uint8_t *udst, uint8_t *vdst, uint8_t *usrc, uint8_t *vsrc, int dststride, int srcstride,
|
|
|
31 int w, int h, float hue, float sat)
|
|
|
32 {
|
|
|
33 int i;
|
|
|
34 const int s= rint(sin(hue) * (1<<16) * sat);
|
|
|
35 const int c= rint(cos(hue) * (1<<16) * sat);
|
|
|
36
|
|
|
37 while (h--) {
|
|
|
38 for (i = 0; i<w; i++)
|
|
|
39 {
|
|
|
40 const int u= usrc[i] - 128;
|
|
|
41 const int v= vsrc[i] - 128;
|
|
|
42 int new_u= (c*u - s*v + (1<<15) + (128<<16))>>16;
|
|
|
43 int new_v= (s*u + c*v + (1<<15) + (128<<16))>>16;
|
|
|
44 if(new_u & 768) new_u= (-new_u)>>31;
|
|
|
45 if(new_v & 768) new_v= (-new_v)>>31;
|
|
|
46 udst[i]= new_u;
|
|
|
47 vdst[i]= new_v;
|
|
|
48 }
|
|
|
49 usrc += srcstride;
|
|
|
50 vsrc += srcstride;
|
|
|
51 udst += dststride;
|
|
|
52 vdst += dststride;
|
|
|
53 }
|
|
|
54 }
|
|
|
55
|
|
|
56 static void (*process)(uint8_t *udst, uint8_t *vdst, uint8_t *usrc, uint8_t *vsrc, int dststride, int srcstride,
|
|
|
57 int w, int h, float hue, float sat);
|
|
|
58
|
|
|
59 /* FIXME: add packed yuv version of process */
|
|
|
60
|
|
17906
|
61 static int put_image(struct vf_instance_s* vf, mp_image_t *mpi, double pts)
|
|
11249
|
62 {
|
|
|
63 mp_image_t *dmpi;
|
|
|
64
|
|
|
65 dmpi=vf_get_image(vf->next, mpi->imgfmt,
|
|
|
66 MP_IMGTYPE_EXPORT, 0,
|
|
|
67 mpi->w, mpi->h);
|
|
29263
|
68
|
|
11249
|
69 dmpi->planes[0] = mpi->planes[0];
|
|
|
70 dmpi->stride[0] = mpi->stride[0];
|
|
|
71 dmpi->stride[1] = mpi->stride[1];
|
|
|
72 dmpi->stride[2] = mpi->stride[2];
|
|
|
73
|
|
|
74 if (!vf->priv->buf[0]){
|
|
|
75 vf->priv->buf[0] = malloc(mpi->stride[1]*mpi->h >> mpi->chroma_y_shift);
|
|
|
76 vf->priv->buf[1] = malloc(mpi->stride[2]*mpi->h >> mpi->chroma_y_shift);
|
|
|
77 }
|
|
29263
|
78
|
|
13232
|
79 if (vf->priv->hue == 0 && vf->priv->saturation == 1){
|
|
11249
|
80 dmpi->planes[1] = mpi->planes[1];
|
|
|
81 dmpi->planes[2] = mpi->planes[2];
|
|
|
82 }else {
|
|
|
83 dmpi->planes[1] = vf->priv->buf[0];
|
|
|
84 dmpi->planes[2] = vf->priv->buf[1];
|
|
|
85 process(dmpi->planes[1], dmpi->planes[2],
|
|
|
86 mpi->planes[1], mpi->planes[2],
|
|
|
87 dmpi->stride[1],mpi->stride[1],
|
|
29263
|
88 mpi->w>> mpi->chroma_x_shift, mpi->h>> mpi->chroma_y_shift,
|
|
11249
|
89 vf->priv->hue, vf->priv->saturation);
|
|
|
90 }
|
|
|
91
|
|
17906
|
92 return vf_next_put_image(vf,dmpi, pts);
|
|
11249
|
93 }
|
|
|
94
|
|
|
95 static int control(struct vf_instance_s* vf, int request, void* data)
|
|
|
96 {
|
|
|
97 vf_equalizer_t *eq;
|
|
|
98
|
|
|
99 switch (request) {
|
|
|
100 case VFCTRL_SET_EQUALIZER:
|
|
|
101 eq = data;
|
|
|
102 if (!strcmp(eq->item,"hue")) {
|
|
|
103 vf->priv->hue = eq->value * M_PI / 100;
|
|
|
104 return CONTROL_TRUE;
|
|
|
105 } else if (!strcmp(eq->item,"saturation")) {
|
|
16305
|
106 vf->priv->saturation = (eq->value + 100)/100.0;
|
|
11249
|
107 return CONTROL_TRUE;
|
|
|
108 }
|
|
|
109 break;
|
|
|
110 case VFCTRL_GET_EQUALIZER:
|
|
|
111 eq = data;
|
|
|
112 if (!strcmp(eq->item,"hue")) {
|
|
|
113 eq->value = rint(vf->priv->hue *100 / M_PI);
|
|
|
114 return CONTROL_TRUE;
|
|
|
115 }else if (!strcmp(eq->item,"saturation")) {
|
|
|
116 eq->value = rint(vf->priv->saturation*100 - 100);
|
|
|
117 return CONTROL_TRUE;
|
|
|
118 }
|
|
|
119 break;
|
|
|
120 }
|
|
|
121 return vf_next_control(vf, request, data);
|
|
|
122 }
|
|
|
123
|
|
|
124 static int query_format(struct vf_instance_s* vf, unsigned int fmt)
|
|
|
125 {
|
|
|
126 switch (fmt) {
|
|
|
127 case IMGFMT_YVU9:
|
|
|
128 case IMGFMT_IF09:
|
|
|
129 case IMGFMT_YV12:
|
|
|
130 case IMGFMT_I420:
|
|
|
131 case IMGFMT_IYUV:
|
|
|
132 case IMGFMT_CLPL:
|
|
|
133 case IMGFMT_444P:
|
|
|
134 case IMGFMT_422P:
|
|
|
135 case IMGFMT_411P:
|
|
|
136 return vf_next_query_format(vf, fmt);
|
|
|
137 }
|
|
|
138 return 0;
|
|
|
139 }
|
|
|
140
|
|
|
141 static void uninit(struct vf_instance_s* vf)
|
|
|
142 {
|
|
|
143 if (vf->priv->buf[0]) free(vf->priv->buf[0]);
|
|
|
144 if (vf->priv->buf[1]) free(vf->priv->buf[1]);
|
|
|
145 free(vf->priv);
|
|
|
146 }
|
|
|
147
|
|
|
148 static int open(vf_instance_t *vf, char* args)
|
|
|
149 {
|
|
|
150 vf->control=control;
|
|
|
151 vf->query_format=query_format;
|
|
|
152 vf->put_image=put_image;
|
|
|
153 vf->uninit=uninit;
|
|
29263
|
154
|
|
11249
|
155 vf->priv->hue *= M_PI / 180.0;
|
|
|
156
|
|
|
157 process = process_C;
|
|
|
158 return 1;
|
|
|
159 }
|
|
|
160
|
|
|
161 #define ST_OFF(f) M_ST_OFF(struct vf_priv_s,f)
|
|
|
162 static m_option_t vf_opts_fields[] = {
|
|
|
163 {"hue", ST_OFF(hue), CONF_TYPE_FLOAT, M_OPT_RANGE,-180.0 ,180.0, NULL},
|
|
|
164 {"saturation", ST_OFF(saturation), CONF_TYPE_FLOAT, M_OPT_RANGE,-10.0 ,10.0, NULL},
|
|
|
165 { NULL, NULL, 0, 0, 0, 0, NULL }
|
|
|
166 };
|
|
|
167
|
|
|
168 static m_struct_t vf_opts = {
|
|
|
169 "hue",
|
|
|
170 sizeof(struct vf_priv_s),
|
|
|
171 &vf_priv_dflt,
|
|
|
172 vf_opts_fields
|
|
|
173 };
|
|
|
174
|
|
25221
|
175 const vf_info_t vf_info_hue = {
|
|
11249
|
176 "hue changer",
|
|
|
177 "hue",
|
|
|
178 "Michael Niedermayer",
|
|
|
179 "",
|
|
|
180 open,
|
|
|
181 &vf_opts
|
|
|
182 };
|
|
|
183
|
