Update .po files
[platform/upstream/gst-plugins-good.git] / gst / goom / ifs.c
1 /*-
2  * Copyright (c) 1997 by Massimino Pascal <Pascal.Massimon@ens.fr>
3  *
4  * ifs.c: modified iterated functions system for goom.
5  *
6  * Permission to use, copy, modify, and distribute this software and its
7  * documentation for any purpose and without fee is hereby granted,
8  * provided that the above copyright notice appear in all copies and that
9  * both that copyright notice and this permission notice appear in
10  * supporting documentation.
11  *
12  * This file is provided AS IS with no warranties of any kind.  The author
13  * shall have no liability with respect to the infringement of copyrights,
14  * trade secrets or any patents by this file or any part thereof.  In no
15  * event will the author be liable for any lost revenue or profits or
16  * other special, indirect and consequential damages.
17  *
18  * If this mode is weird and you have an old MetroX server, it is buggy.
19  * There is a free SuSE-enhanced MetroX X server that is fine.
20  *
21  * When shown ifs, Diana Rose (4 years old) said, "It looks like dancing."
22  *
23  * Revision History:
24  * 13-Dec-2003: Added some goom specific stuffs (to make ifs a VisualFX).
25  * 11-Apr-2002: jeko@ios-software.com: Make ifs.c system-indendant. (ifs.h added)
26  * 01-Nov-2000: Allocation checks
27  * 10-May-1997: jwz@jwz.org: turned into a standalone program.
28  *              Made it render into an offscreen bitmap and then copy
29  *              that onto the screen, to reduce flicker.
30  */
31
32 /* #ifdef STANDALONE */
33
34 #include <math.h>
35 #include <stdlib.h>
36 #include <stdio.h>
37
38 #include "goom_config.h"
39
40 #ifdef HAVE_MMX
41 #include "mmx.h"
42 #endif
43
44 #include "goom_graphic.h"
45 #include "ifs.h"
46 #include "goom_tools.h"
47
48 typedef struct _ifsPoint
49 {
50   gint32 x, y;
51 }
52 IFSPoint;
53
54
55 #define MODE_ifs
56
57 #define PROGCLASS "IFS"
58
59 #define HACK_INIT init_ifs
60 #define HACK_DRAW draw_ifs
61
62 #define ifs_opts xlockmore_opts
63
64 #define DEFAULTS "*delay: 20000 \n" \
65 "*ncolors: 100 \n"
66
67 #define SMOOTH_COLORS
68
69 #define LRAND()            ((long) (goom_random(goomInfo->gRandom) & 0x7fffffff))
70 #define NRAND(n)           ((int) (LRAND() % (n)))
71
72 #if RAND_MAX < 0x10000
73 #define MAXRAND (((float)(RAND_MAX<16)+((float)RAND_MAX)+1.0f)/127.0f)
74 #else
75 #define MAXRAND            (2147483648.0/127.0) /* unsigned 1<<31 / 127.0 (cf goom_tools) as a float */
76 #endif
77
78 /*****************************************************/
79
80 typedef float DBL;
81 typedef int F_PT;
82
83 /* typedef float               F_PT; */
84
85 /*****************************************************/
86
87 #define FIX 12
88 #define UNIT   ( 1<<FIX )
89 #define MAX_SIMI  6
90
91 #define MAX_DEPTH_2  10
92 #define MAX_DEPTH_3  6
93 #define MAX_DEPTH_4  4
94 #define MAX_DEPTH_5  2
95
96 /* PREVIOUS VALUE 
97 #define MAX_SIMI  6
98
99  * settings for a PC 120Mhz... *
100 #define MAX_DEPTH_2  10
101 #define MAX_DEPTH_3  6
102 #define MAX_DEPTH_4  4
103 #define MAX_DEPTH_5  3
104 */
105
106 #define DBL_To_F_PT(x)  (F_PT)( (DBL)(UNIT)*(x) )
107
108 typedef struct Similitude_Struct SIMI;
109 typedef struct Fractal_Struct FRACTAL;
110
111 struct Similitude_Struct
112 {
113
114   DBL c_x, c_y;
115   DBL r, r2, A, A2;
116   F_PT Ct, St, Ct2, St2;
117   F_PT Cx, Cy;
118   F_PT R, R2;
119 };
120
121
122 struct Fractal_Struct
123 {
124
125   int Nb_Simi;
126   SIMI Components[5 * MAX_SIMI];
127   int Depth, Col;
128   int Count, Speed;
129   int Width, Height, Lx, Ly;
130   DBL r_mean, dr_mean, dr2_mean;
131   int Cur_Pt, Max_Pt;
132
133   IFSPoint *Buffer1, *Buffer2;
134 };
135
136 typedef struct _IFS_DATA
137 {
138   FRACTAL *Root;
139   FRACTAL *Cur_F;
140
141   /* Used by the Trace recursive method */
142   IFSPoint *Buf;
143   int Cur_Pt;
144   int initalized;
145 } IfsData;
146
147
148 /*****************************************************/
149
150 static DBL
151 Gauss_Rand (PluginInfo * goomInfo, DBL c, DBL A, DBL S)
152 {
153   DBL y;
154
155   y = (DBL) LRAND () / MAXRAND;
156   y = A * (1.0 - exp (-y * y * S)) / (1.0 - exp (-S));
157   if (NRAND (2))
158     return (c + y);
159   return (c - y);
160 }
161
162 static DBL
163 Half_Gauss_Rand (PluginInfo * goomInfo, DBL c, DBL A, DBL S)
164 {
165   DBL y;
166
167   y = (DBL) LRAND () / MAXRAND;
168   y = A * (1.0 - exp (-y * y * S)) / (1.0 - exp (-S));
169   return (c + y);
170 }
171
172 static void
173 Random_Simis (PluginInfo * goomInfo, FRACTAL * F, SIMI * Cur, int i)
174 {
175   while (i--) {
176     Cur->c_x = Gauss_Rand (goomInfo, 0.0, .8, 4.0);
177     Cur->c_y = Gauss_Rand (goomInfo, 0.0, .8, 4.0);
178     Cur->r = Gauss_Rand (goomInfo, F->r_mean, F->dr_mean, 3.0);
179     Cur->r2 = Half_Gauss_Rand (goomInfo, 0.0, F->dr2_mean, 2.0);
180     Cur->A = Gauss_Rand (goomInfo, 0.0, 360.0, 4.0) * (G_PI / 180.0);
181     Cur->A2 = Gauss_Rand (goomInfo, 0.0, 360.0, 4.0) * (G_PI / 180.0);
182     Cur++;
183   }
184 }
185
186 static void
187 free_ifs_buffers (FRACTAL * Fractal)
188 {
189   if (Fractal->Buffer1 != NULL) {
190     (void) free ((void *) Fractal->Buffer1);
191     Fractal->Buffer1 = (IFSPoint *) NULL;
192   }
193   if (Fractal->Buffer2 != NULL) {
194     (void) free ((void *) Fractal->Buffer2);
195     Fractal->Buffer2 = (IFSPoint *) NULL;
196   }
197 }
198
199
200 static void
201 free_ifs (FRACTAL * Fractal)
202 {
203   free_ifs_buffers (Fractal);
204 }
205
206 /***************************************************************/
207
208 static void
209 init_ifs (PluginInfo * goomInfo, IfsData * data)
210 {
211   int i;
212   FRACTAL *Fractal;
213   int width = goomInfo->screen.width;
214   int height = goomInfo->screen.height;
215
216   if (data->Root == NULL) {
217     data->Root = (FRACTAL *) malloc (sizeof (FRACTAL));
218     if (data->Root == NULL)
219       return;
220     data->Root->Buffer1 = (IFSPoint *) NULL;
221     data->Root->Buffer2 = (IFSPoint *) NULL;
222   }
223   Fractal = data->Root;
224
225   free_ifs_buffers (Fractal);
226
227   i = (NRAND (4)) + 2;          /* Number of centers */
228   switch (i) {
229     case 3:
230       Fractal->Depth = MAX_DEPTH_3;
231       Fractal->r_mean = .6;
232       Fractal->dr_mean = .4;
233       Fractal->dr2_mean = .3;
234       break;
235
236     case 4:
237       Fractal->Depth = MAX_DEPTH_4;
238       Fractal->r_mean = .5;
239       Fractal->dr_mean = .4;
240       Fractal->dr2_mean = .3;
241       break;
242
243     case 5:
244       Fractal->Depth = MAX_DEPTH_5;
245       Fractal->r_mean = .5;
246       Fractal->dr_mean = .4;
247       Fractal->dr2_mean = .3;
248       break;
249
250     default:
251     case 2:
252       Fractal->Depth = MAX_DEPTH_2;
253       Fractal->r_mean = .7;
254       Fractal->dr_mean = .3;
255       Fractal->dr2_mean = .4;
256       break;
257   }
258   Fractal->Nb_Simi = i;
259   Fractal->Max_Pt = Fractal->Nb_Simi - 1;
260   for (i = 0; i <= Fractal->Depth + 2; ++i)
261     Fractal->Max_Pt *= Fractal->Nb_Simi;
262
263   if ((Fractal->Buffer1 = (IFSPoint *) calloc (Fractal->Max_Pt,
264               sizeof (IFSPoint))) == NULL) {
265     free_ifs (Fractal);
266     return;
267   }
268   if ((Fractal->Buffer2 = (IFSPoint *) calloc (Fractal->Max_Pt,
269               sizeof (IFSPoint))) == NULL) {
270     free_ifs (Fractal);
271     return;
272   }
273
274   Fractal->Speed = 6;
275   Fractal->Width = width;       /* modif by JeKo */
276   Fractal->Height = height;     /* modif by JeKo */
277   Fractal->Cur_Pt = 0;
278   Fractal->Count = 0;
279   Fractal->Lx = (Fractal->Width - 1) / 2;
280   Fractal->Ly = (Fractal->Height - 1) / 2;
281   Fractal->Col = rand () % (width * height);    /* modif by JeKo */
282
283   Random_Simis (goomInfo, Fractal, Fractal->Components, 5 * MAX_SIMI);
284 }
285
286
287 /***************************************************************/
288
289 static inline void
290 Transform (SIMI * Simi, F_PT xo, F_PT yo, F_PT * x, F_PT * y)
291 {
292   F_PT xx, yy;
293
294   xo = xo - Simi->Cx;
295   xo = (xo * Simi->R) >> FIX;   /* / UNIT; */
296   yo = yo - Simi->Cy;
297   yo = (yo * Simi->R) >> FIX;   /* / UNIT; */
298
299   xx = xo - Simi->Cx;
300   xx = (xx * Simi->R2) >> FIX;  /* / UNIT; */
301   yy = -yo - Simi->Cy;
302   yy = (yy * Simi->R2) >> FIX;  /* / UNIT; */
303
304   *x = ((xo * Simi->Ct - yo * Simi->St + xx * Simi->Ct2 - yy * Simi->St2)
305       >> FIX /* / UNIT */ ) + Simi->Cx;
306   *y = ((xo * Simi->St + yo * Simi->Ct + xx * Simi->St2 + yy * Simi->Ct2)
307       >> FIX /* / UNIT */ ) + Simi->Cy;
308 }
309
310 /***************************************************************/
311
312 static void
313 Trace (FRACTAL * F, F_PT xo, F_PT yo, IfsData * data)
314 {
315   F_PT x, y, i;
316   SIMI *Cur;
317
318   Cur = data->Cur_F->Components;
319   for (i = data->Cur_F->Nb_Simi; i; --i, Cur++) {
320     Transform (Cur, xo, yo, &x, &y);
321
322     data->Buf->x = F->Lx + ((x * F->Lx) >> (FIX + 1) /* /(UNIT*2) */ );
323     data->Buf->y = F->Ly - ((y * F->Ly) >> (FIX + 1) /* /(UNIT*2) */ );
324     data->Buf++;
325
326     data->Cur_Pt++;
327
328     if (F->Depth && ((x - xo) >> 4) && ((y - yo) >> 4)) {
329       F->Depth--;
330       Trace (F, x, y, data);
331       F->Depth++;
332     }
333   }
334 }
335
336 static void
337 Draw_Fractal (IfsData * data)
338 {
339   FRACTAL *F = data->Root;
340   int i, j;
341   F_PT x, y, xo, yo;
342   SIMI *Cur, *Simi;
343
344   for (Cur = F->Components, i = F->Nb_Simi; i; --i, Cur++) {
345     Cur->Cx = DBL_To_F_PT (Cur->c_x);
346     Cur->Cy = DBL_To_F_PT (Cur->c_y);
347
348     Cur->Ct = DBL_To_F_PT (cos (Cur->A));
349     Cur->St = DBL_To_F_PT (sin (Cur->A));
350     Cur->Ct2 = DBL_To_F_PT (cos (Cur->A2));
351     Cur->St2 = DBL_To_F_PT (sin (Cur->A2));
352
353     Cur->R = DBL_To_F_PT (Cur->r);
354     Cur->R2 = DBL_To_F_PT (Cur->r2);
355   }
356
357
358   data->Cur_Pt = 0;
359   data->Cur_F = F;
360   data->Buf = F->Buffer2;
361   for (Cur = F->Components, i = F->Nb_Simi; i; --i, Cur++) {
362     xo = Cur->Cx;
363     yo = Cur->Cy;
364     for (Simi = F->Components, j = F->Nb_Simi; j; --j, Simi++) {
365       if (Simi == Cur)
366         continue;
367       Transform (Simi, xo, yo, &x, &y);
368       Trace (F, x, y, data);
369     }
370   }
371
372   /* Erase previous */
373
374   F->Cur_Pt = data->Cur_Pt;
375   data->Buf = F->Buffer1;
376   F->Buffer1 = F->Buffer2;
377   F->Buffer2 = data->Buf;
378 }
379
380
381 static IFSPoint *
382 draw_ifs (PluginInfo * goomInfo, int *nbpt, IfsData * data)
383 {
384   int i;
385   DBL u, uu, v, vv, u0, u1, u2, u3;
386   SIMI *S, *S1, *S2, *S3, *S4;
387   FRACTAL *F;
388
389   if (data->Root == NULL)
390     return NULL;
391   F = data->Root;
392   if (F->Buffer1 == NULL)
393     return NULL;
394
395   u = (DBL) (F->Count) * (DBL) (F->Speed) / 1000.0;
396   uu = u * u;
397   v = 1.0 - u;
398   vv = v * v;
399   u0 = vv * v;
400   u1 = 3.0 * vv * u;
401   u2 = 3.0 * v * uu;
402   u3 = u * uu;
403
404   S = F->Components;
405   S1 = S + F->Nb_Simi;
406   S2 = S1 + F->Nb_Simi;
407   S3 = S2 + F->Nb_Simi;
408   S4 = S3 + F->Nb_Simi;
409
410   for (i = F->Nb_Simi; i; --i, S++, S1++, S2++, S3++, S4++) {
411     S->c_x = u0 * S1->c_x + u1 * S2->c_x + u2 * S3->c_x + u3 * S4->c_x;
412     S->c_y = u0 * S1->c_y + u1 * S2->c_y + u2 * S3->c_y + u3 * S4->c_y;
413     S->r = u0 * S1->r + u1 * S2->r + u2 * S3->r + u3 * S4->r;
414     S->r2 = u0 * S1->r2 + u1 * S2->r2 + u2 * S3->r2 + u3 * S4->r2;
415     S->A = u0 * S1->A + u1 * S2->A + u2 * S3->A + u3 * S4->A;
416     S->A2 = u0 * S1->A2 + u1 * S2->A2 + u2 * S3->A2 + u3 * S4->A2;
417   }
418
419   Draw_Fractal (data);
420
421   if (F->Count >= 1000 / F->Speed) {
422     S = F->Components;
423     S1 = S + F->Nb_Simi;
424     S2 = S1 + F->Nb_Simi;
425     S3 = S2 + F->Nb_Simi;
426     S4 = S3 + F->Nb_Simi;
427
428     for (i = F->Nb_Simi; i; --i, S++, S1++, S2++, S3++, S4++) {
429       S2->c_x = 2.0 * S4->c_x - S3->c_x;
430       S2->c_y = 2.0 * S4->c_y - S3->c_y;
431       S2->r = 2.0 * S4->r - S3->r;
432       S2->r2 = 2.0 * S4->r2 - S3->r2;
433       S2->A = 2.0 * S4->A - S3->A;
434       S2->A2 = 2.0 * S4->A2 - S3->A2;
435
436       *S1 = *S4;
437     }
438     Random_Simis (goomInfo, F, F->Components + 3 * F->Nb_Simi, F->Nb_Simi);
439
440     Random_Simis (goomInfo, F, F->Components + 4 * F->Nb_Simi, F->Nb_Simi);
441
442     F->Count = 0;
443   } else
444     F->Count++;
445
446   F->Col++;
447
448   (*nbpt) = data->Cur_Pt;
449   return F->Buffer2;
450 }
451
452
453 /***************************************************************/
454
455 static void
456 release_ifs (IfsData * data)
457 {
458   if (data->Root != NULL) {
459     free_ifs (data->Root);
460     (void) free ((void *) data->Root);
461     data->Root = (FRACTAL *) NULL;
462   }
463 }
464
465 #define RAND() goom_random(goomInfo->gRandom)
466
467 static void
468 ifs_update (PluginInfo * goomInfo, Pixel * data, Pixel * back, int increment,
469     IfsData * fx_data)
470 {
471   static unsigned int couleur = 0xc0c0c0c0;
472   static int v[4] = { 2, 4, 3, 2 };
473   static int col[4] = { 2, 4, 3, 2 };
474
475 #define MOD_MER 0
476 #define MOD_FEU 1
477 #define MOD_MERVER 2
478   static int mode = MOD_MERVER;
479   static int justChanged = 0;
480   static int cycle = 0;
481   int cycle10;
482
483   int nbpt = 0;
484   IFSPoint *points;
485   int i;
486
487   unsigned int couleursl = couleur;
488   int width = goomInfo->screen.width;
489   int height = goomInfo->screen.height;
490
491   cycle++;
492   if (cycle >= 80)
493     cycle = 0;
494
495   if (cycle < 40)
496     cycle10 = cycle / 10;
497   else
498     cycle10 = 7 - cycle / 10;
499
500   {
501     unsigned char *tmp = (unsigned char *) &couleursl;
502
503     for (i = 0; i < 4; i++) {
504       *tmp = (*tmp) >> cycle10;
505       tmp++;
506     }
507   }
508
509   points = draw_ifs (goomInfo, &nbpt, fx_data);
510   nbpt--;
511
512 #ifdef HAVE_MMX
513   movd_m2r (couleursl, mm1);
514   punpckldq_r2r (mm1, mm1);
515   for (i = 0; i < nbpt; i += increment) {
516     int x = points[i].x;
517     int y = points[i].y;
518
519     if ((x < width) && (y < height) && (x > 0) && (y > 0)) {
520       int pos = x + (y * width);
521
522       movd_m2r (back[pos], mm0);
523       paddusb_r2r (mm1, mm0);
524       movd_r2m (mm0, data[pos]);
525     }
526   }
527   emms ();     /*__asm__ __volatile__ ("emms");*/
528 #else
529   for (i = 0; i < nbpt; i += increment) {
530     int x = (int) points[i].x & 0x7fffffff;
531     int y = (int) points[i].y & 0x7fffffff;
532
533     if ((x < width) && (y < height)) {
534       int pos = x + (int) (y * width);
535       int tra = 0, i = 0;
536       unsigned char *bra = (unsigned char *) &back[pos];
537       unsigned char *dra = (unsigned char *) &data[pos];
538       unsigned char *cra = (unsigned char *) &couleursl;
539
540       for (; i < 4; i++) {
541         tra = *cra;
542         tra += *bra;
543         if (tra > 255)
544           tra = 255;
545         *dra = tra;
546         ++dra;
547         ++cra;
548         ++bra;
549       }
550     }
551   }
552 #endif /*MMX*/
553       justChanged--;
554
555   col[ALPHA] = couleur >> (ALPHA * 8) & 0xff;
556   col[BLEU] = couleur >> (BLEU * 8) & 0xff;
557   col[VERT] = couleur >> (VERT * 8) & 0xff;
558   col[ROUGE] = couleur >> (ROUGE * 8) & 0xff;
559
560   if (mode == MOD_MER) {
561     col[BLEU] += v[BLEU];
562     if (col[BLEU] > 255) {
563       col[BLEU] = 255;
564       v[BLEU] = -(RAND () % 4) - 1;
565     }
566     if (col[BLEU] < 32) {
567       col[BLEU] = 32;
568       v[BLEU] = (RAND () % 4) + 1;
569     }
570
571     col[VERT] += v[VERT];
572     if (col[VERT] > 200) {
573       col[VERT] = 200;
574       v[VERT] = -(RAND () % 3) - 2;
575     }
576     if (col[VERT] > col[BLEU]) {
577       col[VERT] = col[BLEU];
578       v[VERT] = v[BLEU];
579     }
580     if (col[VERT] < 32) {
581       col[VERT] = 32;
582       v[VERT] = (RAND () % 3) + 2;
583     }
584
585     col[ROUGE] += v[ROUGE];
586     if (col[ROUGE] > 64) {
587       col[ROUGE] = 64;
588       v[ROUGE] = -(RAND () % 4) - 1;
589     }
590     if (col[ROUGE] < 0) {
591       col[ROUGE] = 0;
592       v[ROUGE] = (RAND () % 4) + 1;
593     }
594
595     col[ALPHA] += v[ALPHA];
596     if (col[ALPHA] > 0) {
597       col[ALPHA] = 0;
598       v[ALPHA] = -(RAND () % 4) - 1;
599     }
600     if (col[ALPHA] < 0) {
601       col[ALPHA] = 0;
602       v[ALPHA] = (RAND () % 4) + 1;
603     }
604
605     if (((col[VERT] > 32) && (col[ROUGE] < col[VERT] + 40)
606             && (col[VERT] < col[ROUGE] + 20) && (col[BLEU] < 64)
607             && (RAND () % 20 == 0)) && (justChanged < 0)) {
608       mode = (RAND () % 3) ? MOD_FEU : MOD_MERVER;
609       justChanged = 250;
610     }
611   } else if (mode == MOD_MERVER) {
612     col[BLEU] += v[BLEU];
613     if (col[BLEU] > 128) {
614       col[BLEU] = 128;
615       v[BLEU] = -(RAND () % 4) - 1;
616     }
617     if (col[BLEU] < 16) {
618       col[BLEU] = 16;
619       v[BLEU] = (RAND () % 4) + 1;
620     }
621
622     col[VERT] += v[VERT];
623     if (col[VERT] > 200) {
624       col[VERT] = 200;
625       v[VERT] = -(RAND () % 3) - 2;
626     }
627     if (col[VERT] > col[ALPHA]) {
628       col[VERT] = col[ALPHA];
629       v[VERT] = v[ALPHA];
630     }
631     if (col[VERT] < 32) {
632       col[VERT] = 32;
633       v[VERT] = (RAND () % 3) + 2;
634     }
635
636     col[ROUGE] += v[ROUGE];
637     if (col[ROUGE] > 128) {
638       col[ROUGE] = 128;
639       v[ROUGE] = -(RAND () % 4) - 1;
640     }
641     if (col[ROUGE] < 0) {
642       col[ROUGE] = 0;
643       v[ROUGE] = (RAND () % 4) + 1;
644     }
645
646     col[ALPHA] += v[ALPHA];
647     if (col[ALPHA] > 255) {
648       col[ALPHA] = 255;
649       v[ALPHA] = -(RAND () % 4) - 1;
650     }
651     if (col[ALPHA] < 0) {
652       col[ALPHA] = 0;
653       v[ALPHA] = (RAND () % 4) + 1;
654     }
655
656     if (((col[VERT] > 32) && (col[ROUGE] < col[VERT] + 40)
657             && (col[VERT] < col[ROUGE] + 20) && (col[BLEU] < 64)
658             && (RAND () % 20 == 0)) && (justChanged < 0)) {
659       mode = (RAND () % 3) ? MOD_FEU : MOD_MER;
660       justChanged = 250;
661     }
662   } else if (mode == MOD_FEU) {
663
664     col[BLEU] += v[BLEU];
665     if (col[BLEU] > 64) {
666       col[BLEU] = 64;
667       v[BLEU] = -(RAND () % 4) - 1;
668     }
669     if (col[BLEU] < 0) {
670       col[BLEU] = 0;
671       v[BLEU] = (RAND () % 4) + 1;
672     }
673
674     col[VERT] += v[VERT];
675     if (col[VERT] > 200) {
676       col[VERT] = 200;
677       v[VERT] = -(RAND () % 3) - 2;
678     }
679     if (col[VERT] > col[ROUGE] + 20) {
680       col[VERT] = col[ROUGE] + 20;
681       v[VERT] = -(RAND () % 3) - 2;
682       v[ROUGE] = (RAND () % 4) + 1;
683       v[BLEU] = (RAND () % 4) + 1;
684     }
685     if (col[VERT] < 0) {
686       col[VERT] = 0;
687       v[VERT] = (RAND () % 3) + 2;
688     }
689
690     col[ROUGE] += v[ROUGE];
691     if (col[ROUGE] > 255) {
692       col[ROUGE] = 255;
693       v[ROUGE] = -(RAND () % 4) - 1;
694     }
695     if (col[ROUGE] > col[VERT] + 40) {
696       col[ROUGE] = col[VERT] + 40;
697       v[ROUGE] = -(RAND () % 4) - 1;
698     }
699     if (col[ROUGE] < 0) {
700       col[ROUGE] = 0;
701       v[ROUGE] = (RAND () % 4) + 1;
702     }
703
704     col[ALPHA] += v[ALPHA];
705     if (col[ALPHA] > 0) {
706       col[ALPHA] = 0;
707       v[ALPHA] = -(RAND () % 4) - 1;
708     }
709     if (col[ALPHA] < 0) {
710       col[ALPHA] = 0;
711       v[ALPHA] = (RAND () % 4) + 1;
712     }
713
714     if (((col[ROUGE] < 64) && (col[VERT] > 32) && (col[VERT] < col[BLEU])
715             && (col[BLEU] > 32)
716             && (RAND () % 20 == 0)) && (justChanged < 0)) {
717       mode = (RAND () % 2) ? MOD_MER : MOD_MERVER;
718       justChanged = 250;
719     }
720   }
721
722   couleur = (col[ALPHA] << (ALPHA * 8))
723       | (col[BLEU] << (BLEU * 8))
724       | (col[VERT] << (VERT * 8))
725       | (col[ROUGE] << (ROUGE * 8));
726 }
727
728 /** VISUAL_FX WRAPPER FOR IFS */
729
730 static void
731 ifs_vfx_apply (VisualFX * _this, Pixel * src, Pixel * dest,
732     PluginInfo * goomInfo)
733 {
734
735   IfsData *data = (IfsData *) _this->fx_data;
736
737   if (!data->initalized) {
738     data->initalized = 1;
739     init_ifs (goomInfo, data);
740   }
741   ifs_update (goomInfo, dest, src, goomInfo->update.ifs_incr, data);
742   /*TODO: trouver meilleur soluce pour increment (mettre le code de gestion de l'ifs dans ce fichier: ifs_vfx_apply) */
743 }
744
745 static void
746 ifs_vfx_init (VisualFX * _this, PluginInfo * info)
747 {
748
749   IfsData *data = (IfsData *) malloc (sizeof (IfsData));
750
751   data->Root = (FRACTAL *) NULL;
752   data->initalized = 0;
753   _this->fx_data = data;
754 }
755
756 static void
757 ifs_vfx_free (VisualFX * _this)
758 {
759   IfsData *data = (IfsData *) _this->fx_data;
760
761   release_ifs (data);
762   free (data);
763 }
764
765 void
766 ifs_visualfx_create (VisualFX * vfx)
767 {
768
769   vfx->init = ifs_vfx_init;
770   vfx->free = ifs_vfx_free;
771   vfx->apply = ifs_vfx_apply;
772   vfx->fx_data = NULL;
773   vfx->params = NULL;
774 }