2 * Copyright (C) 2009 Loren Merritt <lorenm@u.washignton.edu>
4 * This file is part of MPlayer.
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.
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.
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.
22 * Debanding algorithm (from gradfun2db by prunedtree):
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.
36 #include "cpudetect.h"
37 #include "img_format.h"
40 #include "libvo/fastmemcpy.h"
41 #include "libavutil/avutil.h"
42 #include "ffmpeg_files/x86_cpu.h"
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
);
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 },
67 static void filter_line_c(uint8_t *dst
, uint8_t *src
, uint16_t *dc
,
68 int width
, int thresh
, const uint16_t *dithers
)
71 for (x
=0; x
<width
; x
++, dc
+=x
&1) {
73 int delta
= dc
[0] - pix
;
74 int m
= abs(delta
) * thresh
>> 16;
77 pix
+= m
+ dithers
[x
&7];
78 dst
[x
] = av_clip_uint8(pix
>>7);
82 static void blur_line_c(uint16_t *dc
, uint16_t *buf
, uint16_t *buf1
,
83 uint8_t *src
, int sstride
, int width
)
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
];
95 static void filter_line_mmx2(uint8_t *dst
, uint8_t *src
, uint16_t *dc
,
96 int width
, int thresh
, const uint16_t *dithers
)
101 filter_line_c(dst
+x
, src
+x
, dc
+x
/2, width
-x
, thresh
, dithers
);
107 "pxor %%mm7, %%mm7 \n"
108 "pshufw $0, %%mm5, %%mm5 \n"
112 "movd (%2,%0), %%mm0 \n"
113 "movd (%3,%0), %%mm1 \n"
114 "punpcklbw %%mm7, %%mm0 \n"
115 "punpcklwd %%mm1, %%mm1 \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
130 "packuswb %%mm0, %%mm0 \n"
131 "movd %%mm0, (%1,%0) \n" // dst = clip(pix>>7)
136 :"r"(dst
+width
), "r"(src
+width
), "r"(dc
+width
/2),
137 "rm"(thresh
), "m"(*dithers
), "m"(*pw_7f
)
142 static void filter_line_ssse3(uint8_t *dst
, uint8_t *src
, uint16_t *dc
,
143 int width
, int thresh
, const uint16_t *dithers
)
147 // could be 10% faster if I somehow eliminated this
149 filter_line_c(dst
+x
, src
+x
, dc
+x
/2, width
-x
, thresh
, dithers
);
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"
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)
182 :"r"(dst
+width
), "r"(src
+width
), "r"(dc
+width
/2),
183 "rm"(thresh
), "m"(*dithers
), "m"(*pw_7f
)
189 intptr_t x = -2*width;\
191 "movdqa %6, %%xmm7 \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"\
216 "r"(src+width*2+sstride),\
222 static void blur_line_sse2(uint16_t *dc
, uint16_t *buf
, uint16_t *buf1
,
223 uint8_t *src
, int sstride
, int width
)
225 if (((intptr_t)src
|sstride
)&15) {
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
)
237 int bstride
= ((width
+15)&~15)/2;
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
;
244 memset(dc
, 0, (bstride
+16)*sizeof(*buf
));
246 ctx
->blur_line(dc
, buf
+y
*bstride
, buf
+(y
-1)*bstride
, src
+2*y
*sstride
, sstride
, width
/2);
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
;
253 ctx
->blur_line(dc
, buf0
, buf1
, src
+(y
+r
)*sstride
, sstride
, width
/2);
254 for (x
=v
=0; x
<r
; x
++)
256 for (; x
<width
/2; x
++) {
257 v
+= dc
[x
] - dc
[x
-r
];
258 dc
[x
-r
] = v
* dc_factor
>> 16;
260 for (; x
<(width
+r
+1)/2; x
++)
261 dc
[x
-r
] = v
* dc_factor
>> 16;
262 for (x
=-r
/2; x
<0; x
++)
267 ctx
->filter_line(dst
+y
*dstride
, src
+y
*sstride
, dc
-r
/2, width
, thresh
, dither
[y
&7]);
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;
276 static void get_image(struct vf_instance
*vf
, mp_image_t
*mpi
)
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];
291 mpi
->flags
|= MP_IMGFLAG_DIRECT
;
294 static int put_image(struct vf_instance
*vf
, mp_image_t
*mpi
, double pts
)
296 mp_image_t
*dmpi
= vf
->dmpi
;
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
,
305 vf_clone_mpi_attributes(dmpi
, mpi
);
307 for (p
=0; p
<mpi
->num_planes
; p
++) {
310 int r
= vf
->priv
->radius
;
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);
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
]);
325 return vf_next_put_image(vf
, dmpi
, pts
);
328 static int query_format(struct vf_instance
*vf
, unsigned int fmt
)
345 return vf_next_query_format(vf
,fmt
);
350 static int config(struct vf_instance
*vf
,
351 int width
, int height
, int d_width
, int d_height
,
352 unsigned int flags
, unsigned int outfmt
)
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
);
359 static void uninit(struct vf_instance
*vf
)
361 if (!vf
->priv
) return;
362 av_free(vf
->priv
->buf
);
367 static int vf_open(vf_instance_t
*vf
, char *args
)
372 vf
->get_image
=get_image
;
373 vf
->put_image
=put_image
;
374 vf
->query_format
=query_format
;
377 vf
->priv
=malloc(sizeof(struct vf_priv_s
));
378 memset(vf
->priv
, 0, sizeof(struct vf_priv_s
));
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);
384 vf
->priv
->blur_line
= blur_line_c
;
385 vf
->priv
->filter_line
= filter_line_c
;
388 if (gCpuCaps
.hasSSE2
)
389 vf
->priv
->blur_line
= blur_line_sse2
;
391 if (gCpuCaps
.hasMMX2
)
392 vf
->priv
->filter_line
= filter_line_mmx2
;
393 if (gCpuCaps
.hasSSSE3
)
394 vf
->priv
->filter_line
= filter_line_ssse3
;
400 const vf_info_t vf_info_gradfun
= {