2 Copyright (C) 2002 Michael Niedermayer <michaelni@gmx.at>
4 This program 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.
9 This program 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.
14 You should have received a copy of the GNU General Public License
15 along with this program; if not, write to the Free Software
16 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
25 #include "../config.h"
26 #include "../mp_msg.h"
27 #include "../cpudetect.h"
33 #include "img_format.h"
36 #include "../libvo/fastmemcpy.h"
38 #define MAX_NOISE 4096
39 #define MAX_SHIFT 1024
40 #define MAX_RES (MAX_NOISE-MAX_SHIFT)
42 //===========================================================================//
44 static inline void lineNoise_C(uint8_t *dst
, uint8_t *src
, int8_t *noise
, int len
, int shift
);
45 static inline void lineNoiseAvg_C(uint8_t *dst
, uint8_t *src
, int len
, int8_t **shift
);
47 static void (*lineNoise
)(uint8_t *dst
, uint8_t *src
, int8_t *noise
, int len
, int shift
)= lineNoise_C
;
48 static void (*lineNoiseAvg
)(uint8_t *dst
, uint8_t *src
, int len
, int8_t **shift
)= lineNoiseAvg_C
;
50 typedef struct FilterParam
{
59 int8_t *prev_shift
[MAX_RES
][3];
63 FilterParam lumaParam
;
64 FilterParam chromaParam
;
68 static int nonTempRandShift
[MAX_RES
]= {-1};
70 static int patt
[4] = {
74 #define RAND_N(range) ((int) ((double)range*rand()/(RAND_MAX+1.0)))
75 static int8_t *initNoise(FilterParam
*fp
){
76 int strength
= fp
->strength
;
77 int uniform
= fp
->uniform
;
78 int averaged
= fp
->averaged
;
79 int pattern
= fp
->pattern
;
80 int8_t *noise
= memalign(16, MAX_NOISE
*sizeof(int8_t));
85 for(i
=0,j
=0; i
<MAX_NOISE
; i
++,j
++)
90 noise
[i
]= (RAND_N(strength
) - strength
/2)/6
91 +patt
[j
%4]*strength
*0.25/3;
93 noise
[i
]= (RAND_N(strength
) - strength
/2)/3;
97 noise
[i
]= (RAND_N(strength
) - strength
/2)/2
98 + patt
[j
%4]*strength
*0.25;
100 noise
[i
]= RAND_N(strength
) - strength
/2;
104 double x1
, x2
, w
, y1
;
106 x1
= 2.0 * rand()/(float)RAND_MAX
- 1.0;
107 x2
= 2.0 * rand()/(float)RAND_MAX
- 1.0;
108 w
= x1
* x1
+ x2
* x2
;
109 } while ( w
>= 1.0 );
111 w
= sqrt( (-2.0 * log( w
) ) / w
);
113 y1
*= strength
/ sqrt(3.0);
116 y1
+= patt
[j
%4]*strength
*0.35;
118 if (y1
<-128) y1
=-128;
119 else if(y1
> 127) y1
= 127;
120 if (averaged
) y1
/= 3.0;
123 if (RAND_N(6) == 0) j
--;
127 for (i
= 0; i
< MAX_RES
; i
++)
128 for (j
= 0; j
< 3; j
++)
129 fp
->prev_shift
[i
][j
] = noise
+ (rand()&(MAX_SHIFT
-1));
131 if(nonTempRandShift
[0]==-1){
132 for(i
=0; i
<MAX_RES
; i
++){
133 nonTempRandShift
[i
]= rand()&(MAX_SHIFT
-1);
142 /***************************************************************************/
145 static inline void lineNoise_MMX(uint8_t *dst
, uint8_t *src
, int8_t *noise
, int len
, int shift
){
146 long mmx_len
= len
&(~7);
150 "mov %3, %%"REG_a
" \n\t"
151 "pcmpeqb %%mm7, %%mm7 \n\t"
152 "psllw $15, %%mm7 \n\t"
153 "packsswb %%mm7, %%mm7 \n\t"
156 "movq (%0, %%"REG_a
"), %%mm0 \n\t"
157 "movq (%1, %%"REG_a
"), %%mm1 \n\t"
158 "pxor %%mm7, %%mm0 \n\t"
159 "paddsb %%mm1, %%mm0 \n\t"
160 "pxor %%mm7, %%mm0 \n\t"
161 "movq %%mm0, (%2, %%"REG_a
") \n\t"
162 "add $8, %%"REG_a
" \n\t"
164 :: "r" (src
+mmx_len
), "r" (noise
+mmx_len
), "r" (dst
+mmx_len
), "g" (-mmx_len
)
168 lineNoise_C(dst
+mmx_len
, src
+mmx_len
, noise
+mmx_len
, len
-mmx_len
, 0);
172 //duplicate of previous except movntq
174 static inline void lineNoise_MMX2(uint8_t *dst
, uint8_t *src
, int8_t *noise
, int len
, int shift
){
175 long mmx_len
= len
&(~7);
179 "mov %3, %%"REG_a
" \n\t"
180 "pcmpeqb %%mm7, %%mm7 \n\t"
181 "psllw $15, %%mm7 \n\t"
182 "packsswb %%mm7, %%mm7 \n\t"
185 "movq (%0, %%"REG_a
"), %%mm0 \n\t"
186 "movq (%1, %%"REG_a
"), %%mm1 \n\t"
187 "pxor %%mm7, %%mm0 \n\t"
188 "paddsb %%mm1, %%mm0 \n\t"
189 "pxor %%mm7, %%mm0 \n\t"
190 "movntq %%mm0, (%2, %%"REG_a
") \n\t"
191 "add $8, %%"REG_a
" \n\t"
193 :: "r" (src
+mmx_len
), "r" (noise
+mmx_len
), "r" (dst
+mmx_len
), "g" (-mmx_len
)
197 lineNoise_C(dst
+mmx_len
, src
+mmx_len
, noise
+mmx_len
, len
-mmx_len
, 0);
201 static inline void lineNoise_C(uint8_t *dst
, uint8_t *src
, int8_t *noise
, int len
, int shift
){
206 int v
= src
[i
]+ noise
[i
];
207 if(v
>255) dst
[i
]=255; //FIXME optimize
208 else if(v
<0) dst
[i
]=0;
213 /***************************************************************************/
216 static inline void lineNoiseAvg_MMX(uint8_t *dst
, uint8_t *src
, int len
, int8_t **shift
){
217 long mmx_len
= len
&(~7);
220 "mov %5, %%"REG_a
" \n\t"
223 "movq (%1, %%"REG_a
"), %%mm1 \n\t"
224 "movq (%0, %%"REG_a
"), %%mm0 \n\t"
225 "paddb (%2, %%"REG_a
"), %%mm1 \n\t"
226 "paddb (%3, %%"REG_a
"), %%mm1 \n\t"
227 "movq %%mm0, %%mm2 \n\t"
228 "movq %%mm1, %%mm3 \n\t"
229 "punpcklbw %%mm0, %%mm0 \n\t"
230 "punpckhbw %%mm2, %%mm2 \n\t"
231 "punpcklbw %%mm1, %%mm1 \n\t"
232 "punpckhbw %%mm3, %%mm3 \n\t"
233 "pmulhw %%mm0, %%mm1 \n\t"
234 "pmulhw %%mm2, %%mm3 \n\t"
235 "paddw %%mm1, %%mm1 \n\t"
236 "paddw %%mm3, %%mm3 \n\t"
237 "paddw %%mm0, %%mm1 \n\t"
238 "paddw %%mm2, %%mm3 \n\t"
239 "psrlw $8, %%mm1 \n\t"
240 "psrlw $8, %%mm3 \n\t"
241 "packuswb %%mm3, %%mm1 \n\t"
242 "movq %%mm1, (%4, %%"REG_a
") \n\t"
243 "add $8, %%"REG_a
" \n\t"
245 :: "r" (src
+mmx_len
), "r" (shift
[0]+mmx_len
), "r" (shift
[1]+mmx_len
), "r" (shift
[2]+mmx_len
),
246 "r" (dst
+mmx_len
), "g" (-mmx_len
)
251 int8_t *shift2
[3]={shift
[0]+mmx_len
, shift
[1]+mmx_len
, shift
[2]+mmx_len
};
252 lineNoiseAvg_C(dst
+mmx_len
, src
+mmx_len
, len
-mmx_len
, shift2
);
257 static inline void lineNoiseAvg_C(uint8_t *dst
, uint8_t *src
, int len
, int8_t **shift
){
259 int8_t *src2
= (int8_t*)src
;
263 const int n
= shift
[0][i
] + shift
[1][i
] + shift
[2][i
];
264 dst
[i
]= src2
[i
]+((n
*src2
[i
])>>7);
268 /***************************************************************************/
270 static void noise(uint8_t *dst
, uint8_t *src
, int dstStride
, int srcStride
, int width
, int height
, FilterParam
*fp
){
271 int8_t *noise
= fp
->noise
;
279 if(dstStride
==srcStride
) memcpy(dst
, src
, srcStride
*height
);
282 for(y
=0; y
<height
; y
++)
284 memcpy(dst
, src
, width
);
292 for(y
=0; y
<height
; y
++)
294 if(fp
->temporal
) shift
= rand()&(MAX_SHIFT
-1);
295 else shift
= nonTempRandShift
[y
];
297 if(fp
->quality
==0) shift
&= ~7;
299 lineNoiseAvg(dst
, src
, width
, fp
->prev_shift
[y
]);
300 fp
->prev_shift
[y
][fp
->shiftptr
] = noise
+ shift
;
302 lineNoise(dst
, src
, noise
, width
, shift
);
308 if (fp
->shiftptr
== 3) fp
->shiftptr
= 0;
311 static int config(struct vf_instance_s
* vf
,
312 int width
, int height
, int d_width
, int d_height
,
313 unsigned int flags
, unsigned int outfmt
){
315 return vf_next_config(vf
,width
,height
,d_width
,d_height
,flags
,outfmt
);
318 static void get_image(struct vf_instance_s
* vf
, mp_image_t
*mpi
){
319 if(mpi
->flags
&MP_IMGFLAG_PRESERVE
) return; // don't change
320 if(mpi
->imgfmt
!=vf
->priv
->outfmt
) return; // colorspace differ
321 // ok, we can do pp in-place (or pp disabled):
322 vf
->dmpi
=vf_get_image(vf
->next
,mpi
->imgfmt
,
323 mpi
->type
, mpi
->flags
, mpi
->w
, mpi
->h
);
324 mpi
->planes
[0]=vf
->dmpi
->planes
[0];
325 mpi
->stride
[0]=vf
->dmpi
->stride
[0];
326 mpi
->width
=vf
->dmpi
->width
;
327 if(mpi
->flags
&MP_IMGFLAG_PLANAR
){
328 mpi
->planes
[1]=vf
->dmpi
->planes
[1];
329 mpi
->planes
[2]=vf
->dmpi
->planes
[2];
330 mpi
->stride
[1]=vf
->dmpi
->stride
[1];
331 mpi
->stride
[2]=vf
->dmpi
->stride
[2];
333 mpi
->flags
|=MP_IMGFLAG_DIRECT
;
336 static int put_image(struct vf_instance_s
* vf
, mp_image_t
*mpi
){
339 if(!(mpi
->flags
&MP_IMGFLAG_DIRECT
)){
340 // no DR, so get a new image! hope we'll get DR buffer:
341 vf
->dmpi
=vf_get_image(vf
->next
,vf
->priv
->outfmt
,
342 MP_IMGTYPE_TEMP
, MP_IMGFLAG_ACCEPT_STRIDE
,
346 //else printf("dr\n");
349 noise(dmpi
->planes
[0], mpi
->planes
[0], dmpi
->stride
[0], mpi
->stride
[0], mpi
->w
, mpi
->h
, &vf
->priv
->lumaParam
);
350 noise(dmpi
->planes
[1], mpi
->planes
[1], dmpi
->stride
[1], mpi
->stride
[1], mpi
->w
/2, mpi
->h
/2, &vf
->priv
->chromaParam
);
351 noise(dmpi
->planes
[2], mpi
->planes
[2], dmpi
->stride
[2], mpi
->stride
[2], mpi
->w
/2, mpi
->h
/2, &vf
->priv
->chromaParam
);
353 vf_clone_mpi_attributes(dmpi
, mpi
);
356 if(gCpuCaps
.hasMMX
) asm volatile ("emms\n\t");
359 if(gCpuCaps
.hasMMX2
) asm volatile ("sfence\n\t");
362 return vf_next_put_image(vf
,dmpi
);
365 static void uninit(struct vf_instance_s
* vf
){
366 if(!vf
->priv
) return;
368 if(vf
->priv
->chromaParam
.noise
) free(vf
->priv
->chromaParam
.noise
);
369 vf
->priv
->chromaParam
.noise
= NULL
;
371 if(vf
->priv
->lumaParam
.noise
) free(vf
->priv
->lumaParam
.noise
);
372 vf
->priv
->lumaParam
.noise
= NULL
;
378 //===========================================================================//
380 static int query_format(struct vf_instance_s
* vf
, unsigned int fmt
){
386 return vf_next_query_format(vf
,vf
->priv
->outfmt
);
391 static void parse(FilterParam
*fp
, char* args
){
393 char *max
= strchr(args
, ':');
395 if(!max
) max
= args
+ strlen(args
);
397 fp
->strength
= atoi(args
);
398 pos
= strchr(args
, 'u');
399 if(pos
&& pos
<max
) fp
->uniform
=1;
400 pos
= strchr(args
, 't');
401 if(pos
&& pos
<max
) fp
->temporal
=1;
402 pos
= strchr(args
, 'h');
403 if(pos
&& pos
<max
) fp
->quality
=1;
404 pos
= strchr(args
, 'p');
405 if(pos
&& pos
<max
) fp
->pattern
=1;
406 pos
= strchr(args
, 'a');
412 if(fp
->strength
) initNoise(fp
);
415 static unsigned int fmt_list
[]={
422 static int open(vf_instance_t
*vf
, char* args
){
424 vf
->put_image
=put_image
;
425 vf
->get_image
=get_image
;
426 vf
->query_format
=query_format
;
428 vf
->priv
=malloc(sizeof(struct vf_priv_s
));
429 memset(vf
->priv
, 0, sizeof(struct vf_priv_s
));
432 char *arg2
= strchr(args
,':');
433 if(arg2
) parse(&vf
->priv
->chromaParam
, arg2
+1);
434 parse(&vf
->priv
->lumaParam
, args
);
438 vf
->priv
->outfmt
=vf_match_csp(&vf
->next
,fmt_list
,IMGFMT_YV12
);
439 if(!vf
->priv
->outfmt
)
442 return 0; // no csp match :(
448 lineNoise
= lineNoise_MMX
;
449 lineNoiseAvg
= lineNoiseAvg_MMX
;
453 if(gCpuCaps
.hasMMX2
) lineNoise
= lineNoise_MMX2
;
454 // if(gCpuCaps.hasMMX) lineNoiseAvg= lineNoiseAvg_MMX2;
460 vf_info_t vf_info_noise
= {
463 "Michael Niedermayer",
469 //===========================================================================//