Mercurial > mplayer.hg
annotate libmpcodecs/vf_gradfun.c @ 30918:be200e917ae1
Remove unused OPTFLAGS variable from config.mak.
author | diego |
---|---|
date | Thu, 25 Mar 2010 19:53:05 +0000 |
parents | a972c1a4a012 |
children | 570e001f2e53 |
rev | line source |
---|---|
29371 | 1 /* |
2 * Copyright (C) 2009 Loren Merritt <lorenm@u.washignton.edu> | |
3 * | |
4 * This file is part of MPlayer. | |
5 * | |
6 * MPlayer is free software; you can redistribute it and/or modify | |
7 * it under the terms of the GNU General Public License as published by | |
8 * the Free Software Foundation; either version 2 of the License, or | |
9 * (at your option) any later version. | |
10 * | |
11 * MPlayer is distributed in the hope that it will be useful, | |
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
14 * GNU General Public License for more details. | |
15 * | |
16 * You should have received a copy of the GNU General Public License along | |
17 * with MPlayer; if not, write to the Free Software Foundation, Inc., | |
18 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. | |
19 */ | |
20 | |
21 /* | |
22 * Debanding algorithm (from gradfun2db by prunedtree): | |
23 * Boxblur. | |
24 * Foreach pixel, if it's within threshold of the blurred value, make it closer. | |
25 * So now we have a smoothed and higher bitdepth version of all the shallow | |
26 * gradients, while leaving detailed areas untouched. | |
27 * Dither it back to 8bit. | |
28 */ | |
29 | |
30 #include <stdio.h> | |
31 #include <stdlib.h> | |
32 #include <string.h> | |
33 #include <inttypes.h> | |
34 | |
35 #include "config.h" | |
36 #include "cpudetect.h" | |
37 #include "img_format.h" | |
38 #include "mp_image.h" | |
39 #include "vf.h" | |
40 #include "libvo/fastmemcpy.h" | |
41 #include "libavutil/avutil.h" | |
42 #include "libavutil/x86_cpu.h" | |
43 | |
44 struct vf_priv_s { | |
45 int thresh; | |
46 int radius; | |
47 uint16_t *buf; | |
48 void (*filter_line)(uint8_t *dst, uint8_t *src, uint16_t *dc, | |
49 int width, int thresh, const uint16_t *dithers); | |
50 void (*blur_line)(uint16_t *dc, uint16_t *buf, uint16_t *buf1, | |
51 uint8_t *src, int sstride, int width); | |
52 }; | |
53 | |
54 static const uint16_t __attribute__((aligned(16))) pw_7f[8] = {127,127,127,127,127,127,127,127}; | |
55 static const uint16_t __attribute__((aligned(16))) pw_ff[8] = {255,255,255,255,255,255,255,255}; | |
56 static const uint16_t __attribute__((aligned(16))) dither[8][8] = { | |
57 { 0, 96, 24,120, 6,102, 30,126 }, | |
58 { 64, 32, 88, 56, 70, 38, 94, 62 }, | |
59 { 16,112, 8,104, 22,118, 14,110 }, | |
60 { 80, 48, 72, 40, 86, 54, 78, 46 }, | |
61 { 4,100, 28,124, 2, 98, 26,122 }, | |
62 { 68, 36, 92, 60, 66, 34, 90, 58 }, | |
63 { 20,116, 12,108, 18,114, 10,106 }, | |
64 { 84, 52, 76, 44, 82, 50, 74, 42 }, | |
65 }; | |
66 | |
67 static void filter_line_c(uint8_t *dst, uint8_t *src, uint16_t *dc, | |
68 int width, int thresh, const uint16_t *dithers) | |
69 { | |
70 int x; | |
71 for (x=0; x<width; x++, dc+=x&1) { | |
72 int pix = src[x]<<7; | |
73 int delta = dc[0] - pix; | |
74 int m = abs(delta) * thresh >> 16; | |
75 m = FFMAX(0, 127-m); | |
76 m = m*m*delta >> 14; | |
77 pix += m + dithers[x&7]; | |
78 dst[x] = av_clip_uint8(pix>>7); | |
79 } | |
80 } | |
81 | |
82 static void blur_line_c(uint16_t *dc, uint16_t *buf, uint16_t *buf1, | |
83 uint8_t *src, int sstride, int width) | |
84 { | |
85 int x, v, old; | |
86 for (x=0; x<width; x++) { | |
87 v = buf1[x] + src[2*x] + src[2*x+1] + src[2*x+sstride] + src[2*x+1+sstride]; | |
88 old = buf[x]; | |
89 buf[x] = v; | |
90 dc[x] = v - old; | |
91 } | |
92 } | |
93 | |
94 #if HAVE_SSSE3 | |
95 static void filter_line_mmx2(uint8_t *dst, uint8_t *src, uint16_t *dc, | |
96 int width, int thresh, const uint16_t *dithers) | |
97 { | |
98 intptr_t x; | |
99 if (width&3) { | |
100 x = width&~3; | |
101 filter_line_c(dst+x, src+x, dc+x/2, width-x, thresh, dithers); | |
102 width = x; | |
103 } | |
104 x = -width; | |
105 asm volatile( | |
106 "movd %4, %%mm5 \n" | |
107 "pxor %%mm7, %%mm7 \n" | |
108 "pshufw $0, %%mm5, %%mm5 \n" | |
109 "movq %6, %%mm6 \n" | |
110 "movq %5, %%mm4 \n" | |
111 "1: \n" | |
112 "movd (%2,%0), %%mm0 \n" | |
113 "movd (%3,%0), %%mm1 \n" | |
114 "punpcklbw %%mm7, %%mm0 \n" | |
115 "punpcklwd %%mm1, %%mm1 \n" | |
116 "psllw $7, %%mm0 \n" | |
117 "pxor %%mm2, %%mm2 \n" | |
118 "psubw %%mm0, %%mm1 \n" // delta = dc - pix | |
119 "psubw %%mm1, %%mm2 \n" | |
120 "pmaxsw %%mm1, %%mm2 \n" | |
121 "pmulhuw %%mm5, %%mm2 \n" // m = abs(delta) * thresh >> 16 | |
122 "psubw %%mm6, %%mm2 \n" | |
123 "pminsw %%mm7, %%mm2 \n" // m = -max(0, 127-m) | |
124 "pmullw %%mm2, %%mm2 \n" | |
125 "paddw %%mm4, %%mm0 \n" // pix += dither | |
126 "pmulhw %%mm2, %%mm1 \n" | |
127 "psllw $2, %%mm1 \n" // m = m*m*delta >> 14 | |
128 "paddw %%mm1, %%mm0 \n" // pix += m | |
129 "psraw $7, %%mm0 \n" | |
130 "packuswb %%mm0, %%mm0 \n" | |
131 "movd %%mm0, (%1,%0) \n" // dst = clip(pix>>7) | |
132 "add $4, %0 \n" | |
133 "jl 1b \n" | |
134 "emms \n" | |
135 :"+r"(x) | |
136 :"r"(dst+width), "r"(src+width), "r"(dc+width/2), | |
137 "rm"(thresh), "m"(*dithers), "m"(*pw_7f) | |
138 :"memory" | |
139 ); | |
140 } | |
141 | |
142 static void filter_line_ssse3(uint8_t *dst, uint8_t *src, uint16_t *dc, | |
143 int width, int thresh, const uint16_t *dithers) | |
144 { | |
145 intptr_t x; | |
146 if (width&7) { | |
147 // could be 10% faster if I somehow eliminated this | |
148 x = width&~7; | |
149 filter_line_c(dst+x, src+x, dc+x/2, width-x, thresh, dithers); | |
150 width = x; | |
151 } | |
152 x = -width; | |
153 asm volatile( | |
154 "movd %4, %%xmm5 \n" | |
155 "pxor %%xmm7, %%xmm7 \n" | |
156 "pshuflw $0,%%xmm5, %%xmm5 \n" | |
157 "movdqa %6, %%xmm6 \n" | |
158 "punpcklqdq %%xmm5, %%xmm5 \n" | |
159 "movdqa %5, %%xmm4 \n" | |
160 "1: \n" | |
161 "movq (%2,%0), %%xmm0 \n" | |
162 "movq (%3,%0), %%xmm1 \n" | |
163 "punpcklbw %%xmm7, %%xmm0 \n" | |
164 "punpcklwd %%xmm1, %%xmm1 \n" | |
165 "psllw $7, %%xmm0 \n" | |
166 "psubw %%xmm0, %%xmm1 \n" // delta = dc - pix | |
167 "pabsw %%xmm1, %%xmm2 \n" | |
168 "pmulhuw %%xmm5, %%xmm2 \n" // m = abs(delta) * thresh >> 16 | |
169 "psubw %%xmm6, %%xmm2 \n" | |
170 "pminsw %%xmm7, %%xmm2 \n" // m = -max(0, 127-m) | |
171 "pmullw %%xmm2, %%xmm2 \n" | |
172 "psllw $1, %%xmm2 \n" | |
173 "paddw %%xmm4, %%xmm0 \n" // pix += dither | |
174 "pmulhrsw %%xmm2, %%xmm1 \n" // m = m*m*delta >> 14 | |
175 "paddw %%xmm1, %%xmm0 \n" // pix += m | |
176 "psraw $7, %%xmm0 \n" | |
177 "packuswb %%xmm0, %%xmm0 \n" | |
178 "movq %%xmm0, (%1,%0) \n" // dst = clip(pix>>7) | |
179 "add $8, %0 \n" | |
180 "jl 1b \n" | |
181 :"+&r"(x) | |
182 :"r"(dst+width), "r"(src+width), "r"(dc+width/2), | |
183 "rm"(thresh), "m"(*dithers), "m"(*pw_7f) | |
184 :"memory" | |
185 ); | |
186 } | |
187 | |
188 #define BLURV(load)\ | |
189 intptr_t x = -2*width;\ | |
190 asm volatile(\ | |
191 "movdqa %6, %%xmm7 \n"\ | |
192 "1: \n"\ | |
193 load" (%4,%0), %%xmm0 \n"\ | |
194 load" (%5,%0), %%xmm1 \n"\ | |
195 "movdqa %%xmm0, %%xmm2 \n"\ | |
196 "movdqa %%xmm1, %%xmm3 \n"\ | |
197 "psrlw $8, %%xmm0 \n"\ | |
198 "psrlw $8, %%xmm1 \n"\ | |
199 "pand %%xmm7, %%xmm2 \n"\ | |
200 "pand %%xmm7, %%xmm3 \n"\ | |
201 "paddw %%xmm1, %%xmm0 \n"\ | |
202 "paddw %%xmm3, %%xmm2 \n"\ | |
203 "paddw %%xmm2, %%xmm0 \n"\ | |
204 "paddw (%2,%0), %%xmm0 \n"\ | |
205 "movdqa (%1,%0), %%xmm1 \n"\ | |
206 "movdqa %%xmm0, (%1,%0) \n"\ | |
207 "psubw %%xmm1, %%xmm0 \n"\ | |
208 "movdqa %%xmm0, (%3,%0) \n"\ | |
209 "add $16, %0 \n"\ | |
210 "jl 1b \n"\ | |
211 :"+&r"(x)\ | |
212 :"r"(buf+width),\ | |
213 "r"(buf1+width),\ | |
214 "r"(dc+width),\ | |
215 "r"(src+width*2),\ | |
216 "r"(src+width*2+sstride),\ | |
217 "m"(*pw_ff)\ | |
218 :"memory"\ | |
219 ); | |
220 | |
221 #if HAVE_6REGS | |
222 static void blur_line_sse2(uint16_t *dc, uint16_t *buf, uint16_t *buf1, | |
223 uint8_t *src, int sstride, int width) | |
224 { | |
225 if (((intptr_t)src|sstride)&15) { | |
226 BLURV("movdqu"); | |
227 } else { | |
228 BLURV("movdqa"); | |
229 } | |
230 } | |
231 #endif // HAVE_6REGS | |
232 #endif // HAVE_SSSE3 | |
233 | |
234 static void filter(struct vf_priv_s *ctx, uint8_t *dst, uint8_t *src, | |
235 int width, int height, int dstride, int sstride, int r) | |
236 { | |
237 int bstride = ((width+15)&~15)/2; | |
238 int y; | |
239 uint32_t dc_factor = (1<<21)/(r*r); | |
240 uint16_t *dc = ctx->buf+16; | |
241 uint16_t *buf = ctx->buf+bstride+32; | |
242 int thresh = ctx->thresh; | |
243 | |
244 memset(dc, 0, (bstride+16)*sizeof(*buf)); | |
245 for (y=0; y<r; y++) | |
246 ctx->blur_line(dc, buf+y*bstride, buf+(y-1)*bstride, src+2*y*sstride, sstride, width/2); | |
247 for (;;) { | |
248 if (y < height-r) { | |
249 int mod = ((y+r)/2)%r; | |
250 uint16_t *buf0 = buf+mod*bstride; | |
251 uint16_t *buf1 = buf+(mod?mod-1:r-1)*bstride; | |
252 int x, v; | |
253 ctx->blur_line(dc, buf0, buf1, src+(y+r)*sstride, sstride, width/2); | |
254 for (x=v=0; x<r; x++) | |
255 v += dc[x]; | |
256 for (; x<width/2; x++) { | |
257 v += dc[x] - dc[x-r]; | |
258 dc[x-r] = v * dc_factor >> 16; | |
259 } | |
260 for (; x<(width+r+1)/2; x++) | |
261 dc[x-r] = v * dc_factor >> 16; | |
262 for (x=-r/2; x<0; x++) | |
263 dc[x] = dc[0]; | |
264 } | |
265 if (y == r) { | |
266 for (y=0; y<r; y++) | |
267 ctx->filter_line(dst+y*dstride, src+y*sstride, dc-r/2, width, thresh, dither[y&7]); | |
268 } | |
269 ctx->filter_line(dst+y*dstride, src+y*sstride, dc-r/2, width, thresh, dither[y&7]); | |
270 if (++y >= height) break; | |
271 ctx->filter_line(dst+y*dstride, src+y*sstride, dc-r/2, width, thresh, dither[y&7]); | |
272 if (++y >= height) break; | |
273 } | |
274 } | |
275 | |
30642
a972c1a4a012
cosmetics: Rename struct vf_instance_s --> vf_instance.
diego
parents:
30638
diff
changeset
|
276 static void get_image(struct vf_instance *vf, mp_image_t *mpi) |
29371 | 277 { |
278 if (mpi->flags&MP_IMGFLAG_PRESERVE) return; // don't change | |
279 // ok, we can do pp in-place: | |
280 vf->dmpi = vf_get_image(vf->next, mpi->imgfmt, | |
281 mpi->type, mpi->flags, mpi->width, mpi->height); | |
282 mpi->planes[0] = vf->dmpi->planes[0]; | |
283 mpi->stride[0] = vf->dmpi->stride[0]; | |
284 mpi->width = vf->dmpi->width; | |
285 if (mpi->flags&MP_IMGFLAG_PLANAR){ | |
286 mpi->planes[1] = vf->dmpi->planes[1]; | |
287 mpi->planes[2] = vf->dmpi->planes[2]; | |
288 mpi->stride[1] = vf->dmpi->stride[1]; | |
289 mpi->stride[2] = vf->dmpi->stride[2]; | |
290 } | |
291 mpi->flags |= MP_IMGFLAG_DIRECT; | |
292 } | |
293 | |
30642
a972c1a4a012
cosmetics: Rename struct vf_instance_s --> vf_instance.
diego
parents:
30638
diff
changeset
|
294 static int put_image(struct vf_instance *vf, mp_image_t *mpi, double pts) |
29371 | 295 { |
296 mp_image_t *dmpi = vf->dmpi; | |
297 int p; | |
298 | |
299 if (!(mpi->flags&MP_IMGFLAG_DIRECT)) { | |
300 // no DR, so get a new image. hope we'll get DR buffer: | |
301 dmpi = vf_get_image(vf->next,mpi->imgfmt, MP_IMGTYPE_TEMP, | |
302 MP_IMGFLAG_ACCEPT_STRIDE|MP_IMGFLAG_PREFER_ALIGNED_STRIDE, | |
303 mpi->w, mpi->h); | |
304 } | |
305 vf_clone_mpi_attributes(dmpi, mpi); | |
306 | |
307 for (p=0; p<mpi->num_planes; p++) { | |
308 int w = mpi->w; | |
309 int h = mpi->h; | |
310 int r = vf->priv->radius; | |
311 if (p) { | |
312 w >>= mpi->chroma_x_shift; | |
313 h >>= mpi->chroma_y_shift; | |
314 r = ((r>>mpi->chroma_x_shift) + (r>>mpi->chroma_y_shift)) / 2; | |
315 r = av_clip((r+1)&~1,4,32); | |
316 } | |
317 if (FFMIN(w,h) > 2*r) | |
318 filter(vf->priv, dmpi->planes[p], mpi->planes[p], w, h, | |
319 dmpi->stride[p], mpi->stride[p], r); | |
320 else if (dmpi->planes[p] != mpi->planes[p]) | |
321 memcpy_pic(dmpi->planes[p], mpi->planes[p], w, h, | |
322 dmpi->stride[p], mpi->stride[p]); | |
323 } | |
324 | |
325 return vf_next_put_image(vf, dmpi, pts); | |
326 } | |
327 | |
30642
a972c1a4a012
cosmetics: Rename struct vf_instance_s --> vf_instance.
diego
parents:
30638
diff
changeset
|
328 static int query_format(struct vf_instance *vf, unsigned int fmt) |
29371 | 329 { |
330 switch (fmt){ | |
331 case IMGFMT_YVU9: | |
332 case IMGFMT_IF09: | |
333 case IMGFMT_YV12: | |
334 case IMGFMT_I420: | |
335 case IMGFMT_IYUV: | |
336 case IMGFMT_CLPL: | |
337 case IMGFMT_Y800: | |
338 case IMGFMT_Y8: | |
339 case IMGFMT_NV12: | |
340 case IMGFMT_NV21: | |
341 case IMGFMT_444P: | |
342 case IMGFMT_422P: | |
343 case IMGFMT_411P: | |
344 case IMGFMT_HM12: | |
345 return vf_next_query_format(vf,fmt); | |
346 } | |
347 return 0; | |
348 } | |
349 | |
30642
a972c1a4a012
cosmetics: Rename struct vf_instance_s --> vf_instance.
diego
parents:
30638
diff
changeset
|
350 static int config(struct vf_instance *vf, |
29371 | 351 int width, int height, int d_width, int d_height, |
352 unsigned int flags, unsigned int outfmt) | |
353 { | |
354 free(vf->priv->buf); | |
355 vf->priv->buf = av_mallocz((((width+15)&~15)*(vf->priv->radius+1)/2+32)*sizeof(uint16_t)); | |
356 return vf_next_config(vf,width,height,d_width,d_height,flags,outfmt); | |
357 } | |
358 | |
30642
a972c1a4a012
cosmetics: Rename struct vf_instance_s --> vf_instance.
diego
parents:
30638
diff
changeset
|
359 static void uninit(struct vf_instance *vf) |
29371 | 360 { |
361 if (!vf->priv) return; | |
362 av_free(vf->priv->buf); | |
363 free(vf->priv); | |
364 vf->priv = NULL; | |
365 } | |
366 | |
30638
a7b908875c14
Rename open() vf initialization function to vf_open().
diego
parents:
29371
diff
changeset
|
367 static int vf_open(vf_instance_t *vf, char *args) |
29371 | 368 { |
369 float thresh = 1.2; | |
370 int radius = 16; | |
371 | |
372 vf->get_image=get_image; | |
373 vf->put_image=put_image; | |
374 vf->query_format=query_format; | |
375 vf->config=config; | |
376 vf->uninit=uninit; | |
377 vf->priv=malloc(sizeof(struct vf_priv_s)); | |
378 memset(vf->priv, 0, sizeof(struct vf_priv_s)); | |
379 | |
380 if (args) sscanf(args, "%f:%d", &thresh, &radius); | |
381 vf->priv->thresh = (1<<15)/av_clipf(thresh,0.51,255); | |
382 vf->priv->radius = av_clip((radius+1)&~1,4,32); | |
383 | |
384 vf->priv->blur_line = blur_line_c; | |
385 vf->priv->filter_line = filter_line_c; | |
386 #if HAVE_SSSE3 | |
387 #if HAVE_6REGS | |
388 if (gCpuCaps.hasSSE2) | |
389 vf->priv->blur_line = blur_line_sse2; | |
390 #endif | |
391 if (gCpuCaps.hasMMX2) | |
392 vf->priv->filter_line = filter_line_mmx2; | |
393 if (gCpuCaps.hasSSSE3) | |
394 vf->priv->filter_line = filter_line_ssse3; | |
395 #endif | |
396 | |
397 return 1; | |
398 } | |
399 | |
400 const vf_info_t vf_info_gradfun = { | |
401 "gradient deband", | |
402 "gradfun", | |
403 "Loren Merritt", | |
404 "", | |
30638
a7b908875c14
Rename open() vf initialization function to vf_open().
diego
parents:
29371
diff
changeset
|
405 vf_open, |
29371 | 406 NULL |
407 }; |