ffmpeg: set the video filters timebase to the demuxers.
[ffmpeg.git] / libavfilter / libmpcodecs / vf_noise.c
1 /*
2  * Copyright (C) 2002 Michael Niedermayer <michaelni@gmx.at>
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 #include <stdio.h>
22 #include <stdlib.h>
23 #include <string.h>
24 #include <inttypes.h>
25 #include <math.h>
26
27 #include "config.h"
28 #include "mp_msg.h"
29 #include "cpudetect.h"
30
31 #if HAVE_MALLOC_H
32 #include <malloc.h>
33 #endif
34
35 #include "img_format.h"
36 #include "mp_image.h"
37 #include "vf.h"
38 #include "libvo/fastmemcpy.h"
39 #include "libavutil/mem.h"
40
41 #define MAX_NOISE 4096
42 #define MAX_SHIFT 1024
43 #define MAX_RES (MAX_NOISE-MAX_SHIFT)
44
45 //===========================================================================//
46
47 static inline void lineNoise_C(uint8_t *dst, uint8_t *src, int8_t *noise, int len, int shift);
48 static inline void lineNoiseAvg_C(uint8_t *dst, uint8_t *src, int len, int8_t **shift);
49
50 static void (*lineNoise)(uint8_t *dst, uint8_t *src, int8_t *noise, int len, int shift)= lineNoise_C;
51 static void (*lineNoiseAvg)(uint8_t *dst, uint8_t *src, int len, int8_t **shift)= lineNoiseAvg_C;
52
53 typedef struct FilterParam{
54         int strength;
55         int uniform;
56         int temporal;
57         int quality;
58         int averaged;
59         int pattern;
60         int shiftptr;
61         int8_t *noise;
62         int8_t *prev_shift[MAX_RES][3];
63 }FilterParam;
64
65 struct vf_priv_s {
66         FilterParam lumaParam;
67         FilterParam chromaParam;
68         unsigned int outfmt;
69 };
70
71 static int nonTempRandShift_init;
72 static int nonTempRandShift[MAX_RES];
73
74 static int patt[4] = {
75     -1,0,1,0
76 };
77
78 #define RAND_N(range) ((int) ((double)range*rand()/(RAND_MAX+1.0)))
79 static int8_t *initNoise(FilterParam *fp){
80         int strength= fp->strength;
81         int uniform= fp->uniform;
82         int averaged= fp->averaged;
83         int pattern= fp->pattern;
84         int8_t *noise= av_malloc(MAX_NOISE*sizeof(int8_t));
85         int i, j;
86
87         srand(123457);
88
89         for(i=0,j=0; i<MAX_NOISE; i++,j++)
90         {
91                 if(uniform) {
92                         if (averaged) {
93                                     if (pattern) {
94                                         noise[i]= (RAND_N(strength) - strength/2)/6
95                                                 +patt[j%4]*strength*0.25/3;
96                                 } else {
97                                         noise[i]= (RAND_N(strength) - strength/2)/3;
98                                     }
99                         } else {
100                                     if (pattern) {
101                                     noise[i]= (RAND_N(strength) - strength/2)/2
102                                             + patt[j%4]*strength*0.25;
103                                 } else {
104                                         noise[i]= RAND_N(strength) - strength/2;
105                                     }
106                         }
107                     } else {
108                         double x1, x2, w, y1;
109                         do {
110                                 x1 = 2.0 * rand()/(float)RAND_MAX - 1.0;
111                                 x2 = 2.0 * rand()/(float)RAND_MAX - 1.0;
112                                 w = x1 * x1 + x2 * x2;
113                         } while ( w >= 1.0 );
114
115                         w = sqrt( (-2.0 * log( w ) ) / w );
116                         y1= x1 * w;
117                         y1*= strength / sqrt(3.0);
118                         if (pattern) {
119                             y1 /= 2;
120                             y1 += patt[j%4]*strength*0.35;
121                         }
122                         if     (y1<-128) y1=-128;
123                         else if(y1> 127) y1= 127;
124                         if (averaged) y1 /= 3.0;
125                         noise[i]= (int)y1;
126                 }
127                 if (RAND_N(6) == 0) j--;
128         }
129
130
131         for (i = 0; i < MAX_RES; i++)
132             for (j = 0; j < 3; j++)
133                 fp->prev_shift[i][j] = noise + (rand()&(MAX_SHIFT-1));
134
135         if(!nonTempRandShift_init){
136                 for(i=0; i<MAX_RES; i++){
137                         nonTempRandShift[i]= rand()&(MAX_SHIFT-1);
138                 }
139                 nonTempRandShift_init = 1;
140         }
141
142         fp->noise= noise;
143         fp->shiftptr= 0;
144         return noise;
145 }
146
147 /***************************************************************************/
148
149 #if HAVE_MMX
150 static inline void lineNoise_MMX(uint8_t *dst, uint8_t *src, int8_t *noise, int len, int shift){
151         x86_reg mmx_len= len&(~7);
152         noise+=shift;
153
154         __asm__ volatile(
155                 "mov %3, %%"REG_a"                \n\t"
156                 "pcmpeqb %%mm7, %%mm7                \n\t"
157                 "psllw $15, %%mm7                \n\t"
158                 "packsswb %%mm7, %%mm7                \n\t"
159                 ASMALIGN(4)
160                 "1:                                \n\t"
161                 "movq (%0, %%"REG_a"), %%mm0        \n\t"
162                 "movq (%1, %%"REG_a"), %%mm1        \n\t"
163                 "pxor %%mm7, %%mm0                \n\t"
164                 "paddsb %%mm1, %%mm0                \n\t"
165                 "pxor %%mm7, %%mm0                \n\t"
166                 "movq %%mm0, (%2, %%"REG_a")        \n\t"
167                 "add $8, %%"REG_a"                \n\t"
168                 " js 1b                                \n\t"
169                 :: "r" (src+mmx_len), "r" (noise+mmx_len), "r" (dst+mmx_len), "g" (-mmx_len)
170                 : "%"REG_a
171         );
172         if(mmx_len!=len)
173                 lineNoise_C(dst+mmx_len, src+mmx_len, noise+mmx_len, len-mmx_len, 0);
174 }
175 #endif
176
177 //duplicate of previous except movntq
178 #if HAVE_MMX2
179 static inline void lineNoise_MMX2(uint8_t *dst, uint8_t *src, int8_t *noise, int len, int shift){
180         x86_reg mmx_len= len&(~7);
181         noise+=shift;
182
183         __asm__ volatile(
184                 "mov %3, %%"REG_a"                \n\t"
185                 "pcmpeqb %%mm7, %%mm7                \n\t"
186                 "psllw $15, %%mm7                \n\t"
187                 "packsswb %%mm7, %%mm7                \n\t"
188                 ASMALIGN(4)
189                 "1:                                \n\t"
190                 "movq (%0, %%"REG_a"), %%mm0        \n\t"
191                 "movq (%1, %%"REG_a"), %%mm1        \n\t"
192                 "pxor %%mm7, %%mm0                \n\t"
193                 "paddsb %%mm1, %%mm0                \n\t"
194                 "pxor %%mm7, %%mm0                \n\t"
195                 "movntq %%mm0, (%2, %%"REG_a")        \n\t"
196                 "add $8, %%"REG_a"                \n\t"
197                 " js 1b                                \n\t"
198                 :: "r" (src+mmx_len), "r" (noise+mmx_len), "r" (dst+mmx_len), "g" (-mmx_len)
199                 : "%"REG_a
200         );
201         if(mmx_len!=len)
202                 lineNoise_C(dst+mmx_len, src+mmx_len, noise+mmx_len, len-mmx_len, 0);
203 }
204 #endif
205
206 static inline void lineNoise_C(uint8_t *dst, uint8_t *src, int8_t *noise, int len, int shift){
207         int i;
208         noise+= shift;
209         for(i=0; i<len; i++)
210         {
211                 int v= src[i]+ noise[i];
212                 if(v>255)         dst[i]=255; //FIXME optimize
213                 else if(v<0)         dst[i]=0;
214                 else                dst[i]=v;
215         }
216 }
217
218 /***************************************************************************/
219
220 #if HAVE_MMX
221 static inline void lineNoiseAvg_MMX(uint8_t *dst, uint8_t *src, int len, int8_t **shift){
222         x86_reg mmx_len= len&(~7);
223
224         __asm__ volatile(
225                 "mov %5, %%"REG_a"                \n\t"
226                 ASMALIGN(4)
227                 "1:                                \n\t"
228                 "movq (%1, %%"REG_a"), %%mm1        \n\t"
229                 "movq (%0, %%"REG_a"), %%mm0        \n\t"
230                 "paddb (%2, %%"REG_a"), %%mm1        \n\t"
231                 "paddb (%3, %%"REG_a"), %%mm1        \n\t"
232                 "movq %%mm0, %%mm2                \n\t"
233                 "movq %%mm1, %%mm3                \n\t"
234                 "punpcklbw %%mm0, %%mm0                \n\t"
235                 "punpckhbw %%mm2, %%mm2                \n\t"
236                 "punpcklbw %%mm1, %%mm1                \n\t"
237                 "punpckhbw %%mm3, %%mm3                \n\t"
238                 "pmulhw %%mm0, %%mm1                \n\t"
239                 "pmulhw %%mm2, %%mm3                \n\t"
240                 "paddw %%mm1, %%mm1                \n\t"
241                 "paddw %%mm3, %%mm3                \n\t"
242                 "paddw %%mm0, %%mm1                \n\t"
243                 "paddw %%mm2, %%mm3                \n\t"
244                 "psrlw $8, %%mm1                \n\t"
245                 "psrlw $8, %%mm3                \n\t"
246                 "packuswb %%mm3, %%mm1                \n\t"
247                 "movq %%mm1, (%4, %%"REG_a")        \n\t"
248                 "add $8, %%"REG_a"                \n\t"
249                 " js 1b                                \n\t"
250                 :: "r" (src+mmx_len), "r" (shift[0]+mmx_len), "r" (shift[1]+mmx_len), "r" (shift[2]+mmx_len),
251                    "r" (dst+mmx_len), "g" (-mmx_len)
252                 : "%"REG_a
253         );
254
255         if(mmx_len!=len){
256                 int8_t *shift2[3]={shift[0]+mmx_len, shift[1]+mmx_len, shift[2]+mmx_len};
257                 lineNoiseAvg_C(dst+mmx_len, src+mmx_len, len-mmx_len, shift2);
258         }
259 }
260 #endif
261
262 static inline void lineNoiseAvg_C(uint8_t *dst, uint8_t *src, int len, int8_t **shift){
263         int i;
264         int8_t *src2= (int8_t*)src;
265
266         for(i=0; i<len; i++)
267         {
268             const int n= shift[0][i] + shift[1][i] + shift[2][i];
269             dst[i]= src2[i]+((n*src2[i])>>7);
270         }
271 }
272
273 /***************************************************************************/
274
275 static void noise(uint8_t *dst, uint8_t *src, int dstStride, int srcStride, int width, int height, FilterParam *fp){
276         int8_t *noise= fp->noise;
277         int y;
278         int shift=0;
279
280         if(!noise)
281         {
282                 if(src==dst) return;
283
284                 if(dstStride==srcStride) fast_memcpy(dst, src, srcStride*height);
285                 else
286                 {
287                         for(y=0; y<height; y++)
288                         {
289                                 fast_memcpy(dst, src, width);
290                                 dst+= dstStride;
291                                 src+= srcStride;
292                         }
293                 }
294                 return;
295         }
296
297         for(y=0; y<height; y++)
298         {
299                 if(fp->temporal)        shift=  rand()&(MAX_SHIFT  -1);
300                 else                        shift= nonTempRandShift[y];
301
302                 if(fp->quality==0) shift&= ~7;
303                 if (fp->averaged) {
304                     lineNoiseAvg(dst, src, width, fp->prev_shift[y]);
305                     fp->prev_shift[y][fp->shiftptr] = noise + shift;
306                 } else {
307                     lineNoise(dst, src, noise, width, shift);
308                 }
309                 dst+= dstStride;
310                 src+= srcStride;
311         }
312         fp->shiftptr++;
313         if (fp->shiftptr == 3) fp->shiftptr = 0;
314 }
315
316 static int config(struct vf_instance *vf,
317         int width, int height, int d_width, int d_height,
318         unsigned int flags, unsigned int outfmt){
319
320         return vf_next_config(vf,width,height,d_width,d_height,flags,outfmt);
321 }
322
323 static void get_image(struct vf_instance *vf, mp_image_t *mpi){
324     if(mpi->flags&MP_IMGFLAG_PRESERVE) return; // don't change
325     if(mpi->imgfmt!=vf->priv->outfmt) return; // colorspace differ
326     // ok, we can do pp in-place (or pp disabled):
327     vf->dmpi=vf_get_image(vf->next,mpi->imgfmt,
328         mpi->type, mpi->flags, mpi->w, mpi->h);
329     mpi->planes[0]=vf->dmpi->planes[0];
330     mpi->stride[0]=vf->dmpi->stride[0];
331     mpi->width=vf->dmpi->width;
332     if(mpi->flags&MP_IMGFLAG_PLANAR){
333         mpi->planes[1]=vf->dmpi->planes[1];
334         mpi->planes[2]=vf->dmpi->planes[2];
335         mpi->stride[1]=vf->dmpi->stride[1];
336         mpi->stride[2]=vf->dmpi->stride[2];
337     }
338     mpi->flags|=MP_IMGFLAG_DIRECT;
339 }
340
341 static int put_image(struct vf_instance *vf, mp_image_t *mpi, double pts){
342         mp_image_t *dmpi;
343
344         if(!(mpi->flags&MP_IMGFLAG_DIRECT)){
345                 // no DR, so get a new image! hope we'll get DR buffer:
346                 vf->dmpi=vf_get_image(vf->next,vf->priv->outfmt,
347                 MP_IMGTYPE_TEMP, MP_IMGFLAG_ACCEPT_STRIDE,
348                 mpi->w,mpi->h);
349 //printf("nodr\n");
350         }
351 //else printf("dr\n");
352         dmpi= vf->dmpi;
353
354         noise(dmpi->planes[0], mpi->planes[0], dmpi->stride[0], mpi->stride[0], mpi->w, mpi->h, &vf->priv->lumaParam);
355         noise(dmpi->planes[1], mpi->planes[1], dmpi->stride[1], mpi->stride[1], mpi->w/2, mpi->h/2, &vf->priv->chromaParam);
356         noise(dmpi->planes[2], mpi->planes[2], dmpi->stride[2], mpi->stride[2], mpi->w/2, mpi->h/2, &vf->priv->chromaParam);
357
358         vf_clone_mpi_attributes(dmpi, mpi);
359
360 #if HAVE_MMX
361         if(gCpuCaps.hasMMX) __asm__ volatile ("emms\n\t");
362 #endif
363 #if HAVE_MMX2
364         if(gCpuCaps.hasMMX2) __asm__ volatile ("sfence\n\t");
365 #endif
366
367         return vf_next_put_image(vf,dmpi, pts);
368 }
369
370 static void uninit(struct vf_instance *vf){
371         if(!vf->priv) return;
372
373         av_free(vf->priv->chromaParam.noise);
374         vf->priv->chromaParam.noise= NULL;
375
376         av_free(vf->priv->lumaParam.noise);
377         vf->priv->lumaParam.noise= NULL;
378
379         free(vf->priv);
380         vf->priv=NULL;
381 }
382
383 //===========================================================================//
384
385 static int query_format(struct vf_instance *vf, unsigned int fmt){
386         switch(fmt)
387         {
388         case IMGFMT_YV12:
389         case IMGFMT_I420:
390         case IMGFMT_IYUV:
391                 return vf_next_query_format(vf,vf->priv->outfmt);
392         }
393         return 0;
394 }
395
396 static void parse(FilterParam *fp, char* args){
397         char *pos;
398         char *max= strchr(args, ':');
399
400         if(!max) max= args + strlen(args);
401
402         fp->strength= atoi(args);
403         pos= strchr(args, 'u');
404         if(pos && pos<max) fp->uniform=1;
405         pos= strchr(args, 't');
406         if(pos && pos<max) fp->temporal=1;
407         pos= strchr(args, 'h');
408         if(pos && pos<max) fp->quality=1;
409         pos= strchr(args, 'p');
410         if(pos && pos<max) fp->pattern=1;
411         pos= strchr(args, 'a');
412         if(pos && pos<max) {
413             fp->temporal=1;
414             fp->averaged=1;
415         }
416
417         if(fp->strength) initNoise(fp);
418 }
419
420 static const unsigned int fmt_list[]={
421     IMGFMT_YV12,
422     IMGFMT_I420,
423     IMGFMT_IYUV,
424     0
425 };
426
427 static int vf_open(vf_instance_t *vf, char *args){
428     vf->config=config;
429     vf->put_image=put_image;
430     vf->get_image=get_image;
431     vf->query_format=query_format;
432     vf->uninit=uninit;
433     vf->priv=malloc(sizeof(struct vf_priv_s));
434     memset(vf->priv, 0, sizeof(struct vf_priv_s));
435     if(args)
436     {
437         char *arg2= strchr(args,':');
438         if(arg2) parse(&vf->priv->chromaParam, arg2+1);
439         parse(&vf->priv->lumaParam, args);
440     }
441
442     // check csp:
443     vf->priv->outfmt=vf_match_csp(&vf->next,fmt_list,IMGFMT_YV12);
444     if(!vf->priv->outfmt)
445     {
446         uninit(vf);
447         return 0; // no csp match :(
448     }
449
450
451 #if HAVE_MMX
452     if(gCpuCaps.hasMMX){
453         lineNoise= lineNoise_MMX;
454         lineNoiseAvg= lineNoiseAvg_MMX;
455     }
456 #endif
457 #if HAVE_MMX2
458     if(gCpuCaps.hasMMX2) lineNoise= lineNoise_MMX2;
459 //    if(gCpuCaps.hasMMX) lineNoiseAvg= lineNoiseAvg_MMX2;
460 #endif
461
462     return 1;
463 }
464
465 const vf_info_t vf_info_noise = {
466     "noise generator",
467     "noise",
468     "Michael Niedermayer",
469     "",
470     vf_open,
471     NULL
472 };
473
474 //===========================================================================//