gst/goom/goom_core.c - imx-gst-plugins-good - Git at Google

 #include <stdlib.h>
 #include <string.h>
 #include "goom_core.h"
 #include "goom_tools.h"
 #include "filters.h"
 #include "lines.h"

 /*#define VERBOSE */

 #ifdef VERBOSE
 #include <stdio.h>
 #endif

 #define STOP_SPEED 128


 /**-----------------------------------------------------**
  **  SHARED DATA                                        **
  **-----------------------------------------------------**/
 static guint32 *pixel;
 static guint32 *back;
 static guint32 *p1, *p2, *tmp;
 static guint32 cycle;

 guint32 resolx, resoly, buffsize;

 void
 goom_init (guint32 resx, guint32 resy)
 {
 #ifdef VERBOSE
   printf ("GOOM: init (%d, %d);\n", resx, resy);
 #endif
   resolx = resx;
   resoly = resy;
   buffsize = resx * resy;

   pixel = (guint32 *) malloc (buffsize * sizeof (guint32) + 128);
   back = (guint32 *) malloc (buffsize * sizeof (guint32) + 128);
   RAND_INIT (GPOINTER_TO_INT (pixel));
   cycle = 0;

   p1 = (void *) (((unsigned long) pixel + 0x7f) & (~0x7f));
   p2 = (void *) (((unsigned long) back + 0x7f) & (~0x7f));
 }


 void
 goom_set_resolution (guint32 resx, guint32 resy)
 {
   free (pixel);
   free (back);

   resolx = resx;
   resoly = resy;
   buffsize = resx * resy;

   pixel = (guint32 *) malloc (buffsize * sizeof (guint32) + 128);
   memset (pixel, 0, buffsize * sizeof (guint32) + 128);
   back = (guint32 *) malloc (buffsize * sizeof (guint32) + 128);
   memset (back, 0, buffsize * sizeof (guint32) + 128);

   p1 = (void *) (((unsigned long) pixel + 0x7f) & (~0x7f));
   p2 = (void *) (((unsigned long) back + 0x7f) & (~0x7f));
 }


 guint32 *
 goom_update (gint16 data[2][512])
 {
   static int lockvar = 0;	/* pour empecher de nouveaux changements */
   static int goomvar = 0;	/* boucle des gooms */
   static int totalgoom = 0;	/* nombre de gooms par seconds */
   static int agoom = 0;		/* un goom a eu lieu..       */
   static int loopvar = 0;	/* mouvement des points */
   static int speedvar = 0;	/* vitesse des particules */
   static int lineMode = 0;	/* l'effet lineaire a dessiner */
   guint32 *return_val;
   guint32 pointWidth;
   guint32 pointHeight;
   int incvar;			/* volume du son */
   int accelvar;			/* acceleration des particules */
   int i;
   float largfactor;		/* elargissement de l'intervalle d'évolution des points */
   static char goomlimit = 2;	/* sensibilité du goom */
   static ZoomFilterData zfd = {
     128, 8, 16,
     1, 1, 0, WAVE_MODE,
     0, 0, 0
   };

   ZoomFilterData *pzfd;

   /* test if the config has changed, update it if so */
   pointWidth = (resolx * 2) / 5;
   pointHeight = (resoly * 2) / 5;

   /* ! etude du signal ... */
   incvar = 0;
   for (i = 0; i < 512; i++) {
     if (incvar < data[0][i])
       incvar = data[0][i];
   }

   accelvar = incvar / 5000;
   if (speedvar > 5) {
     accelvar--;
     if (speedvar > 20)
       accelvar--;
     if (speedvar > 40)
       speedvar = 40;
   }
   accelvar--;
   speedvar += accelvar;

   if (speedvar < 0)
     speedvar = 0;
   if (speedvar > 40)
     speedvar = 40;


   /* ! calcul du deplacement des petits points ... */

   largfactor = ((float) speedvar / 40.0f + (float) incvar / 50000.0f) / 1.5f;
   if (largfactor > 1.5f)
     largfactor = 1.5f;

   for (i = 1; i * 15 <= speedvar + 15; i++) {
     loopvar += speedvar + 1;

     pointFilter (p1,
 	YELLOW,
 	((pointWidth - 6.0f) * largfactor + 5.0f),
 	((pointHeight - 6.0f) * largfactor + 5.0f),
 	i * 152.0f, 128.0f, loopvar + i * 2032);
     pointFilter (p1, ORANGE,
 	((pointWidth / 2) * largfactor) / i + 10.0f * i,
 	((pointHeight / 2) * largfactor) / i + 10.0f * i,
 	96.0f, i * 80.0f, loopvar / i);
     pointFilter (p1, VIOLET,
 	((pointHeight / 3 + 5.0f) * largfactor) / i + 10.0f * i,
 	((pointHeight / 3 + 5.0f) * largfactor) / i + 10.0f * i,
 	i + 122.0f, 134.0f, loopvar / i);
     pointFilter (p1, BLACK,
 	((pointHeight / 3) * largfactor + 20.0f),
 	((pointHeight / 3) * largfactor + 20.0f),
 	58.0f, i * 66.0f, loopvar / i);
     pointFilter (p1, WHITE,
 	(pointHeight * largfactor + 10.0f * i) / i,
 	(pointHeight * largfactor + 10.0f * i) / i,
 	66.0f, 74.0f, loopvar + i * 500);
   }

   /* par défaut pas de changement de zoom */
   pzfd = NULL;

   /* diminuer de 1 le temps de lockage */
   /* note pour ceux qui n'ont pas suivis : le lockvar permet d'empecher un */
   /* changement d'etat du plugins juste apres un autre changement d'etat. oki ? */
   if (--lockvar < 0)
     lockvar = 0;

   /* temps du goom */
   if (--agoom < 0)
     agoom = 0;

   /* on verifie qu'il ne se pas un truc interressant avec le son. */
   if ((accelvar > goomlimit) || (accelvar < -goomlimit)) {
     /* UN GOOM !!! YAHOO ! */
     totalgoom++;
     agoom = 20;			/* mais pdt 20 cycles, il n'y en aura plus. */
     lineMode = (lineMode + 1) % 20;	/* Tous les 10 gooms on change de mode lineaire */

     /* changement eventuel de mode */
     switch (iRAND (10)) {
       case 0:
       case 1:
       case 2:
 	zfd.mode = WAVE_MODE;
 	zfd.vitesse = STOP_SPEED - 1;
 	zfd.reverse = 0;
 	break;
       case 3:
       case 4:
 	zfd.mode = CRYSTAL_BALL_MODE;
 	break;
       case 5:
 	zfd.mode = AMULETTE_MODE;
 	break;
       case 6:
 	zfd.mode = WATER_MODE;
 	break;
       case 7:
 	zfd.mode = SCRUNCH_MODE;
 	break;
       default:
 	zfd.mode = NORMAL_MODE;
     }
   }

   /* tout ceci ne sera fait qu'en cas de non-blocage */
   if (lockvar == 0) {
     /* reperage de goom (acceleration forte de l'acceleration du volume) */
     /* -> coup de boost de la vitesse si besoin.. */
     if ((accelvar > goomlimit) || (accelvar < -goomlimit)) {
       goomvar++;
       /*if (goomvar % 1 == 0) */
       {
 	guint32 vtmp;
 	guint32 newvit;

 	newvit = STOP_SPEED - speedvar / 2;
 	/* retablir le zoom avant.. */
 	if ((zfd.reverse) && (!(cycle % 12)) && (rand () % 3 == 0)) {
 	  zfd.reverse = 0;
 	  zfd.vitesse = STOP_SPEED - 2;
 	  lockvar = 50;
 	}
 	if (iRAND (10) == 0) {
 	  zfd.reverse = 1;
 	  lockvar = 100;
 	}

 	/* changement de milieu.. */
 	switch (iRAND (20)) {
 	  case 0:
 	    zfd.middleY = resoly - 1;
 	    zfd.middleX = resolx / 2;
 	    break;
 	  case 1:
 	    zfd.middleX = resolx - 1;
 	    break;
 	  case 2:
 	    zfd.middleX = 1;
 	    break;
 	  default:
 	    zfd.middleY = resoly / 2;
 	    zfd.middleX = resolx / 2;
 	}

 	if (zfd.mode == WATER_MODE) {
 	  zfd.middleX = resolx / 2;
 	  zfd.middleY = resoly / 2;
 	}

 	switch (vtmp = (iRAND (27))) {
 	  case 0:
 	    zfd.vPlaneEffect = iRAND (3);
 	    zfd.vPlaneEffect -= iRAND (3);
 	    zfd.hPlaneEffect = iRAND (3);
 	    zfd.hPlaneEffect -= iRAND (3);
 	    break;
 	  case 3:
 	    zfd.vPlaneEffect = 0;
 	    zfd.hPlaneEffect = iRAND (8);
 	    zfd.hPlaneEffect -= iRAND (8);
 	    break;
 	  case 4:
 	  case 5:
 	  case 6:
 	  case 7:
 	    zfd.vPlaneEffect = iRAND (5);
 	    zfd.vPlaneEffect -= iRAND (5);
 	    zfd.hPlaneEffect = -zfd.vPlaneEffect;
 	    break;
 	  case 8:
 	    zfd.hPlaneEffect = 5 + iRAND (8);
 	    zfd.vPlaneEffect = -zfd.hPlaneEffect;
 	    break;
 	  case 9:
 	    zfd.vPlaneEffect = 5 + iRAND (8);
 	    zfd.hPlaneEffect = -zfd.hPlaneEffect;
 	    break;
 	  case 13:
 	    zfd.hPlaneEffect = 0;
 	    zfd.vPlaneEffect = iRAND (10);
 	    zfd.vPlaneEffect -= iRAND (10);
 	    break;
 	  default:
 	    if (vtmp < 10) {
 	      zfd.vPlaneEffect = 0;
 	      zfd.hPlaneEffect = 0;
 	    }
 	}

 	if (iRAND (3) != 0)
 	  zfd.noisify = 0;
 	else {
 	  zfd.noisify = iRAND (3) + 2;
 	  lockvar *= 3;
 	}

 	if (zfd.mode == AMULETTE_MODE) {
 	  zfd.vPlaneEffect = 0;
 	  zfd.hPlaneEffect = 0;
 	  zfd.noisify = 0;
 	}

 	if ((zfd.middleX == 1) || (zfd.middleX == resolx - 1)) {
 	  zfd.vPlaneEffect = 0;
 	  zfd.hPlaneEffect = iRAND (2) ? 0 : zfd.hPlaneEffect;
 	}

 	if (newvit < zfd.vitesse) {	/* on accelere */
 	  pzfd = &zfd;
 	  if (((newvit < STOP_SPEED - 7) &&
 		  (zfd.vitesse < STOP_SPEED - 6) &&
 		  (cycle % 3 == 0)) || (iRAND (40) == 0)) {
 	    zfd.vitesse = STOP_SPEED - 1;
 	    zfd.reverse = !zfd.reverse;
 	  } else {
 	    zfd.vitesse = (newvit + zfd.vitesse * 4) / 5;
 	  }
 	  lockvar += 50;
 	}
       }
     }
     /* mode mega-lent */
     if (iRAND (1000) == 0) {
       /*
          printf ("coup du sort...\n") ;
        */
       pzfd = &zfd;
       zfd.vitesse = STOP_SPEED - 1;
       zfd.pertedec = 8;
       zfd.sqrtperte = 16;
       goomvar = 1;
       lockvar += 70;
     }
   }

   /* gros frein si la musique est calme */
   if ((speedvar < 1) && (zfd.vitesse < STOP_SPEED - 4) && (cycle % 16 == 0)) {
     /*
        printf ("++slow part... %i\n", zfd.vitesse) ;
      */
     pzfd = &zfd;
     zfd.vitesse += 3;
     zfd.pertedec = 8;
     zfd.sqrtperte = 16;
     goomvar = 0;
     /*
        printf ("--slow part... %i\n", zfd.vitesse) ;
      */
   }

   /* baisser regulierement la vitesse... */
   if ((cycle % 73 == 0) && (zfd.vitesse < STOP_SPEED - 5)) {
     /*
        printf ("slow down...\n") ;
      */
     pzfd = &zfd;
     zfd.vitesse++;
   }

   /* arreter de decrémenter au bout d'un certain temps */
   if ((cycle % 101 == 0) && (zfd.pertedec == 7)) {
     pzfd = &zfd;
     zfd.pertedec = 8;
     zfd.sqrtperte = 16;
   }
 #ifdef VERBOSE
   if (pzfd) {
     printf ("GOOM: pzfd->mode = %d\n", pzfd->mode);
   }
 #endif

   /* Zoom here ! */
   zoomFilterFastRGB (p1, p2, pzfd, resolx, resoly);

   /* si on est dans un goom : afficher les lignes... */
   if (agoom > 15)
     goom_lines
 	(data, ((zfd.middleX == resolx / 2) && (zfd.middleY == resoly / 2)
 	    && (zfd.mode != WATER_MODE))
 	? (lineMode / 10) : 0, p2, agoom - 15);

   return_val = p2;
   tmp = p1;
   p1 = p2;
   p2 = tmp;

   /* affichage et swappage des buffers.. */
   cycle++;

   /* tous les 100 cycles : vérifier si le taux de goom est correct */
   /* et le modifier sinon.. */
   if (!(cycle % 100)) {
     if (totalgoom > 15) {
       /*  printf ("less gooms\n") ; */
       goomlimit++;
     } else {
       if ((totalgoom == 0) && (goomlimit > 1))
 	goomlimit--;
     }
     totalgoom = 0;
   }
   return return_val;
 }

 void
 goom_close ()
 {
   if (pixel != NULL)
     free (pixel);
   if (back != NULL)
     free (back);
   pixel = back = NULL;
   RAND_CLOSE ();
 }
	#include <stdlib.h>
	#include <string.h>
	#include "goom_core.h"
	#include "goom_tools.h"
	#include "filters.h"
	#include "lines.h"

	/#define VERBOSE /

	#ifdef VERBOSE
	#include <stdio.h>
	#endif

	#define STOP_SPEED 128


	/-----------------------------------------------------
	SHARED DATA
	-----------------------------------------------------/
	static guint32 *pixel;
	static guint32 *back;
	static guint32 p1, p2, *tmp;
	static guint32 cycle;

	guint32 resolx, resoly, buffsize;

	void
	goom_init (guint32 resx, guint32 resy)
	{
	#ifdef VERBOSE
	printf ("GOOM: init (%d, %d);\n", resx, resy);
	#endif
	resolx = resx;
	resoly = resy;
	buffsize = resx * resy;

	pixel = (guint32 ) malloc (buffsize sizeof (guint32) + 128);
	back = (guint32 ) malloc (buffsize sizeof (guint32) + 128);
	RAND_INIT (GPOINTER_TO_INT (pixel));
	cycle = 0;

	p1 = (void *) (((unsigned long) pixel + 0x7f) & (~0x7f));
	p2 = (void *) (((unsigned long) back + 0x7f) & (~0x7f));
	}


	void
	goom_set_resolution (guint32 resx, guint32 resy)
	{
	free (pixel);
	free (back);

	resolx = resx;
	resoly = resy;
	buffsize = resx * resy;

	pixel = (guint32 ) malloc (buffsize sizeof (guint32) + 128);
	memset (pixel, 0, buffsize * sizeof (guint32) + 128);
	back = (guint32 ) malloc (buffsize sizeof (guint32) + 128);
	memset (back, 0, buffsize * sizeof (guint32) + 128);

	p1 = (void *) (((unsigned long) pixel + 0x7f) & (~0x7f));
	p2 = (void *) (((unsigned long) back + 0x7f) & (~0x7f));
	}


	guint32 *
	goom_update (gint16 data[2][512])
	{
	static int lockvar = 0; /* pour empecher de nouveaux changements */
	static int goomvar = 0; /* boucle des gooms */
	static int totalgoom = 0; /* nombre de gooms par seconds */
	static int agoom = 0; /* un goom a eu lieu.. */
	static int loopvar = 0; /* mouvement des points */
	static int speedvar = 0; /* vitesse des particules */
	static int lineMode = 0; /* l'effet lineaire a dessiner */
	guint32 *return_val;
	guint32 pointWidth;
	guint32 pointHeight;
	int incvar; /* volume du son */
	int accelvar; /* acceleration des particules */
	int i;
	float largfactor; /* elargissement de l'intervalle d'évolution des points */
	static char goomlimit = 2; /* sensibilité du goom */
	static ZoomFilterData zfd = {
	128, 8, 16,
	1, 1, 0, WAVE_MODE,
	0, 0, 0
	};

	ZoomFilterData *pzfd;

	/* test if the config has changed, update it if so */
	pointWidth = (resolx * 2) / 5;
	pointHeight = (resoly * 2) / 5;

	/* ! etude du signal ... */
	incvar = 0;
	for (i = 0; i < 512; i++) {
	if (incvar < data[0][i])
	incvar = data[0][i];
	}

	accelvar = incvar / 5000;
	if (speedvar > 5) {
	accelvar--;
	if (speedvar > 20)
	accelvar--;
	if (speedvar > 40)
	speedvar = 40;
	}
	accelvar--;
	speedvar += accelvar;

	if (speedvar < 0)
	speedvar = 0;
	if (speedvar > 40)
	speedvar = 40;


	/* ! calcul du deplacement des petits points ... */

	largfactor = ((float) speedvar / 40.0f + (float) incvar / 50000.0f) / 1.5f;
	if (largfactor > 1.5f)
	largfactor = 1.5f;

	for (i = 1; i * 15 <= speedvar + 15; i++) {
	loopvar += speedvar + 1;

	pointFilter (p1,
	YELLOW,
	((pointWidth - 6.0f) * largfactor + 5.0f),
	((pointHeight - 6.0f) * largfactor + 5.0f),
	i * 152.0f, 128.0f, loopvar + i * 2032);
	pointFilter (p1, ORANGE,
	((pointWidth / 2) * largfactor) / i + 10.0f * i,
	((pointHeight / 2) * largfactor) / i + 10.0f * i,
	96.0f, i * 80.0f, loopvar / i);
	pointFilter (p1, VIOLET,
	((pointHeight / 3 + 5.0f) * largfactor) / i + 10.0f * i,
	((pointHeight / 3 + 5.0f) * largfactor) / i + 10.0f * i,
	i + 122.0f, 134.0f, loopvar / i);
	pointFilter (p1, BLACK,
	((pointHeight / 3) * largfactor + 20.0f),
	((pointHeight / 3) * largfactor + 20.0f),
	58.0f, i * 66.0f, loopvar / i);
	pointFilter (p1, WHITE,
	(pointHeight * largfactor + 10.0f * i) / i,
	(pointHeight * largfactor + 10.0f * i) / i,
	66.0f, 74.0f, loopvar + i * 500);
	}

	/* par défaut pas de changement de zoom */
	pzfd = NULL;

	/* diminuer de 1 le temps de lockage */
	/* note pour ceux qui n'ont pas suivis : le lockvar permet d'empecher un */
	/* changement d'etat du plugins juste apres un autre changement d'etat. oki ? */
	if (--lockvar < 0)
	lockvar = 0;

	/* temps du goom */
	if (--agoom < 0)
	agoom = 0;

	/* on verifie qu'il ne se pas un truc interressant avec le son. */
	if ((accelvar > goomlimit) \|\| (accelvar < -goomlimit)) {
	/* UN GOOM !!! YAHOO ! */
	totalgoom++;
	agoom = 20; /* mais pdt 20 cycles, il n'y en aura plus. */
	lineMode = (lineMode + 1) % 20; /* Tous les 10 gooms on change de mode lineaire */

	/* changement eventuel de mode */
	switch (iRAND (10)) {
	case 0:
	case 1:
	case 2:
	zfd.mode = WAVE_MODE;
	zfd.vitesse = STOP_SPEED - 1;
	zfd.reverse = 0;
	break;
	case 3:
	case 4:
	zfd.mode = CRYSTAL_BALL_MODE;
	break;
	case 5:
	zfd.mode = AMULETTE_MODE;
	break;
	case 6:
	zfd.mode = WATER_MODE;
	break;
	case 7:
	zfd.mode = SCRUNCH_MODE;
	break;
	default:
	zfd.mode = NORMAL_MODE;
	}
	}

	/* tout ceci ne sera fait qu'en cas de non-blocage */
	if (lockvar == 0) {
	/* reperage de goom (acceleration forte de l'acceleration du volume) */
	/* -> coup de boost de la vitesse si besoin.. */
	if ((accelvar > goomlimit) \|\| (accelvar < -goomlimit)) {
	goomvar++;
	/if (goomvar % 1 == 0) /
	{
	guint32 vtmp;
	guint32 newvit;

	newvit = STOP_SPEED - speedvar / 2;
	/* retablir le zoom avant.. */
	if ((zfd.reverse) && (!(cycle % 12)) && (rand () % 3 == 0)) {
	zfd.reverse = 0;
	zfd.vitesse = STOP_SPEED - 2;
	lockvar = 50;
	}
	if (iRAND (10) == 0) {
	zfd.reverse = 1;
	lockvar = 100;
	}

	/* changement de milieu.. */
	switch (iRAND (20)) {
	case 0:
	zfd.middleY = resoly - 1;
	zfd.middleX = resolx / 2;
	break;
	case 1:
	zfd.middleX = resolx - 1;
	break;
	case 2:
	zfd.middleX = 1;
	break;
	default:
	zfd.middleY = resoly / 2;
	zfd.middleX = resolx / 2;
	}

	if (zfd.mode == WATER_MODE) {
	zfd.middleX = resolx / 2;
	zfd.middleY = resoly / 2;
	}

	switch (vtmp = (iRAND (27))) {
	case 0:
	zfd.vPlaneEffect = iRAND (3);
	zfd.vPlaneEffect -= iRAND (3);
	zfd.hPlaneEffect = iRAND (3);
	zfd.hPlaneEffect -= iRAND (3);
	break;
	case 3:
	zfd.vPlaneEffect = 0;
	zfd.hPlaneEffect = iRAND (8);
	zfd.hPlaneEffect -= iRAND (8);
	break;
	case 4:
	case 5:
	case 6:
	case 7:
	zfd.vPlaneEffect = iRAND (5);
	zfd.vPlaneEffect -= iRAND (5);
	zfd.hPlaneEffect = -zfd.vPlaneEffect;
	break;
	case 8:
	zfd.hPlaneEffect = 5 + iRAND (8);
	zfd.vPlaneEffect = -zfd.hPlaneEffect;
	break;
	case 9:
	zfd.vPlaneEffect = 5 + iRAND (8);
	zfd.hPlaneEffect = -zfd.hPlaneEffect;
	break;
	case 13:
	zfd.hPlaneEffect = 0;
	zfd.vPlaneEffect = iRAND (10);
	zfd.vPlaneEffect -= iRAND (10);
	break;
	default:
	if (vtmp < 10) {
	zfd.vPlaneEffect = 0;
	zfd.hPlaneEffect = 0;
	}
	}

	if (iRAND (3) != 0)
	zfd.noisify = 0;
	else {
	zfd.noisify = iRAND (3) + 2;
	lockvar *= 3;
	}

	if (zfd.mode == AMULETTE_MODE) {
	zfd.vPlaneEffect = 0;
	zfd.hPlaneEffect = 0;
	zfd.noisify = 0;
	}

	if ((zfd.middleX == 1) \|\| (zfd.middleX == resolx - 1)) {
	zfd.vPlaneEffect = 0;
	zfd.hPlaneEffect = iRAND (2) ? 0 : zfd.hPlaneEffect;
	}

	if (newvit < zfd.vitesse) { /* on accelere */
	pzfd = &zfd;
	if (((newvit < STOP_SPEED - 7) &&
	(zfd.vitesse < STOP_SPEED - 6) &&
	(cycle % 3 == 0)) \|\| (iRAND (40) == 0)) {
	zfd.vitesse = STOP_SPEED - 1;
	zfd.reverse = !zfd.reverse;
	} else {
	zfd.vitesse = (newvit + zfd.vitesse * 4) / 5;
	}
	lockvar += 50;
	}
	}
	}
	/* mode mega-lent */
	if (iRAND (1000) == 0) {
	/*
	printf ("coup du sort...\n") ;
	*/
	pzfd = &zfd;
	zfd.vitesse = STOP_SPEED - 1;
	zfd.pertedec = 8;
	zfd.sqrtperte = 16;
	goomvar = 1;
	lockvar += 70;
	}
	}

	/* gros frein si la musique est calme */
	if ((speedvar < 1) && (zfd.vitesse < STOP_SPEED - 4) && (cycle % 16 == 0)) {
	/*
	printf ("++slow part... %i\n", zfd.vitesse) ;
	*/
	pzfd = &zfd;
	zfd.vitesse += 3;
	zfd.pertedec = 8;
	zfd.sqrtperte = 16;
	goomvar = 0;
	/*
	printf ("--slow part... %i\n", zfd.vitesse) ;
	*/
	}

	/* baisser regulierement la vitesse... */
	if ((cycle % 73 == 0) && (zfd.vitesse < STOP_SPEED - 5)) {
	/*
	printf ("slow down...\n") ;
	*/
	pzfd = &zfd;
	zfd.vitesse++;
	}

	/* arreter de decrémenter au bout d'un certain temps */
	if ((cycle % 101 == 0) && (zfd.pertedec == 7)) {
	pzfd = &zfd;
	zfd.pertedec = 8;
	zfd.sqrtperte = 16;
	}
	#ifdef VERBOSE
	if (pzfd) {
	printf ("GOOM: pzfd->mode = %d\n", pzfd->mode);
	}
	#endif

	/* Zoom here ! */
	zoomFilterFastRGB (p1, p2, pzfd, resolx, resoly);

	/* si on est dans un goom : afficher les lignes... */
	if (agoom > 15)
	goom_lines
	(data, ((zfd.middleX == resolx / 2) && (zfd.middleY == resoly / 2)
	&& (zfd.mode != WATER_MODE))
	? (lineMode / 10) : 0, p2, agoom - 15);

	return_val = p2;
	tmp = p1;
	p1 = p2;
	p2 = tmp;

	/* affichage et swappage des buffers.. */
	cycle++;

	/* tous les 100 cycles : vérifier si le taux de goom est correct */
	/* et le modifier sinon.. */
	if (!(cycle % 100)) {
	if (totalgoom > 15) {
	/* printf ("less gooms\n") ; */
	goomlimit++;
	} else {
	if ((totalgoom == 0) && (goomlimit > 1))
	goomlimit--;
	}
	totalgoom = 0;
	}
	return return_val;
	}

	void
	goom_close ()
	{
	if (pixel != NULL)
	free (pixel);
	if (back != NULL)
	free (back);
	pixel = back = NULL;
	RAND_CLOSE ();
	}