configure.ac: Add checks for Flex/Yacc/Bison and other furry animals, for the new goom 2k4 based plugin

Original commit message from CVS:
2008-02-23  Bastien Nocera  <hadess@hadess.net>

* configure.ac: Add checks for Flex/Yacc/Bison and other
furry animals, for the new goom 2k4 based plugin

* gst/goom/*: Update to use goom 2k4, uses liboil to detect
CPU optimisations (not working yet), move the old plugin to...

* gst/goom2k1/*: ... here, in case somebody is sick enough

Fixes #515073

1 files changed, 412 insertions, 0 deletions

diff --git a/gst/goom2k1/goom_core.c b/gst/goom2k1/goom_core.c
new file mode 100644
index 00000000..d66ffe25
--- /dev/null
+++ b/gst/goom2k1/goom_core.c
@@ -0,0 +1,412 @@
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+#include <glib.h>
+
+#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
+
+void
+goom_init (GoomData * goomdata, guint32 resx, guint32 resy)
+{
+#ifdef VERBOSE
+  printf ("GOOM: init (%d, %d);\n", resx, resy);
+#endif
+  goomdata->resolx = 0;
+  goomdata->resoly = 0;
+  goomdata->buffsize = 0;
+
+  goomdata->pixel = NULL;
+  goomdata->back = NULL;
+  goomdata->p1 = NULL;
+  goomdata->p2 = NULL;
+
+  goom_set_resolution (goomdata, resx, resy);
+  RAND_INIT (goomdata, GPOINTER_TO_INT (goomdata->pixel));
+  goomdata->cycle = 0;
+
+
+  goomdata->goomlimit = 2;      /* sensibilité du goom */
+  goomdata->zfd = zoomFilterNew ();
+  goomdata->lockvar = 0;        /* pour empecher de nouveaux changements */
+  goomdata->goomvar = 0;        /* boucle des gooms */
+  goomdata->totalgoom = 0;      /* nombre de gooms par seconds */
+  goomdata->agoom = 0;          /* un goom a eu lieu..       */
+  goomdata->loopvar = 0;        /* mouvement des points */
+  goomdata->speedvar = 0;       /* vitesse des particules */
+  goomdata->lineMode = 0;       /* l'effet lineaire a dessiner */
+}
+
+void
+goom_set_resolution (GoomData * goomdata, guint32 resx, guint32 resy)
+{
+  guint32 buffsize = resx * resy;
+
+  if ((goomdata->resolx == resx) && (goomdata->resoly == resy))
+    return;
+
+  if (goomdata->buffsize < buffsize) {
+    if (goomdata->pixel)
+      free (goomdata->pixel);
+    if (goomdata->back)
+      free (goomdata->back);
+    goomdata->pixel = (guint32 *) malloc (buffsize * sizeof (guint32) + 128);
+    goomdata->back = (guint32 *) malloc (buffsize * sizeof (guint32) + 128);
+    goomdata->buffsize = buffsize;
+
+    goomdata->p1 =
+        (void *) (((unsigned long) goomdata->pixel + 0x7f) & (~0x7f));
+    goomdata->p2 = (void *) (((unsigned long) goomdata->back + 0x7f) & (~0x7f));
+  }
+
+  goomdata->resolx = resx;
+  goomdata->resoly = resy;
+
+  memset (goomdata->pixel, 0, buffsize * sizeof (guint32) + 128);
+  memset (goomdata->back, 0, buffsize * sizeof (guint32) + 128);
+}
+
+guint32 *
+goom_update (GoomData * goomdata, gint16 data[2][512])
+{
+  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 */
+  int zfd_update = 0;
+  int resolx = goomdata->resolx;
+  int resoly = goomdata->resoly;
+  ZoomFilterData *pzfd = goomdata->zfd;
+  guint32 *tmp;
+
+  /* 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 (goomdata->speedvar > 5) {
+    accelvar--;
+    if (goomdata->speedvar > 20)
+      accelvar--;
+    if (goomdata->speedvar > 40)
+      goomdata->speedvar = 40;
+  }
+  accelvar--;
+  goomdata->speedvar += accelvar;
+
+  if (goomdata->speedvar < 0)
+    goomdata->speedvar = 0;
+  if (goomdata->speedvar > 40)
+    goomdata->speedvar = 40;
+
+
+  /* ! calcul du deplacement des petits points ... */
+
+  largfactor =
+      ((float) goomdata->speedvar / 40.0f + (float) incvar / 50000.0f) / 1.5f;
+  if (largfactor > 1.5f)
+    largfactor = 1.5f;
+
+  for (i = 1; i * 15 <= goomdata->speedvar + 15; i++) {
+    goomdata->loopvar += goomdata->speedvar + 1;
+
+    pointFilter (goomdata,
+        YELLOW,
+        ((pointWidth - 6.0f) * largfactor + 5.0f),
+        ((pointHeight - 6.0f) * largfactor + 5.0f),
+        i * 152.0f, 128.0f, goomdata->loopvar + i * 2032);
+    pointFilter (goomdata, ORANGE,
+        ((pointWidth / 2) * largfactor) / i + 10.0f * i,
+        ((pointHeight / 2) * largfactor) / i + 10.0f * i,
+        96.0f, i * 80.0f, goomdata->loopvar / i);
+    pointFilter (goomdata, VIOLET,
+        ((pointHeight / 3 + 5.0f) * largfactor) / i + 10.0f * i,
+        ((pointHeight / 3 + 5.0f) * largfactor) / i + 10.0f * i,
+        i + 122.0f, 134.0f, goomdata->loopvar / i);
+    pointFilter (goomdata, BLACK,
+        ((pointHeight / 3) * largfactor + 20.0f),
+        ((pointHeight / 3) * largfactor + 20.0f),
+        58.0f, i * 66.0f, goomdata->loopvar / i);
+    pointFilter (goomdata, WHITE,
+        (pointHeight * largfactor + 10.0f * i) / i,
+        (pointHeight * largfactor + 10.0f * i) / i,
+        66.0f, 74.0f, goomdata->loopvar + i * 500);
+  }
+
+  /* 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 (--goomdata->lockvar < 0)
+    goomdata->lockvar = 0;
+
+  /* temps du goom */
+  if (--goomdata->agoom < 0)
+    goomdata->agoom = 0;
+
+  /* on verifie qu'il ne se pas un truc interressant avec le son. */
+  if ((accelvar > goomdata->goomlimit) || (accelvar < -goomdata->goomlimit)) {
+    /* UN GOOM !!! YAHOO ! */
+    goomdata->totalgoom++;
+    goomdata->agoom = 20;       /* mais pdt 20 cycles, il n'y en aura plus. */
+    goomdata->lineMode = (goomdata->lineMode + 1) % 20; /* Tous les 10 gooms on change de mode lineaire */
+
+    /* changement eventuel de mode */
+    switch (iRAND (goomdata, 10)) {
+      case 0:
+      case 1:
+      case 2:
+        pzfd->mode = WAVE_MODE;
+        pzfd->vitesse = STOP_SPEED - 1;
+        pzfd->reverse = 0;
+        break;
+      case 3:
+      case 4:
+        pzfd->mode = CRYSTAL_BALL_MODE;
+        break;
+      case 5:
+        pzfd->mode = AMULETTE_MODE;
+        break;
+      case 6:
+        pzfd->mode = WATER_MODE;
+        break;
+      case 7:
+        pzfd->mode = SCRUNCH_MODE;
+        break;
+      default:
+        pzfd->mode = NORMAL_MODE;
+    }
+  }
+
+  /* tout ceci ne sera fait qu'en cas de non-blocage */
+  if (goomdata->lockvar == 0) {
+    /* reperage de goom (acceleration forte de l'acceleration du volume) */
+    /* -> coup de boost de la vitesse si besoin.. */
+    if ((accelvar > goomdata->goomlimit) || (accelvar < -goomdata->goomlimit)) {
+      goomdata->goomvar++;
+      /*if (goomvar % 1 == 0) */
+      {
+        guint32 vtmp;
+        guint32 newvit;
+
+        newvit = STOP_SPEED - goomdata->speedvar / 2;
+        /* retablir le zoom avant.. */
+        if ((pzfd->reverse) && (!(goomdata->cycle % 12)) && (rand () % 3 == 0)) {
+          pzfd->reverse = 0;
+          pzfd->vitesse = STOP_SPEED - 2;
+          goomdata->lockvar = 50;
+        }
+        if (iRAND (goomdata, 10) == 0) {
+          pzfd->reverse = 1;
+          goomdata->lockvar = 100;
+        }
+
+        /* changement de milieu.. */
+        switch (iRAND (goomdata, 20)) {
+          case 0:
+            pzfd->middleY = resoly - 1;
+            pzfd->middleX = resolx / 2;
+            break;
+          case 1:
+            pzfd->middleX = resolx - 1;
+            break;
+          case 2:
+            pzfd->middleX = 1;
+            break;
+          default:
+            pzfd->middleY = resoly / 2;
+            pzfd->middleX = resolx / 2;
+        }
+
+        if (pzfd->mode == WATER_MODE) {
+          pzfd->middleX = resolx / 2;
+          pzfd->middleY = resoly / 2;
+        }
+
+        switch (vtmp = (iRAND (goomdata, 27))) {
+          case 0:
+            pzfd->vPlaneEffect = iRAND (goomdata, 3);
+            pzfd->vPlaneEffect -= iRAND (goomdata, 3);
+            pzfd->hPlaneEffect = iRAND (goomdata, 3);
+            pzfd->hPlaneEffect -= iRAND (goomdata, 3);
+            break;
+          case 3:
+            pzfd->vPlaneEffect = 0;
+            pzfd->hPlaneEffect = iRAND (goomdata, 8);
+            pzfd->hPlaneEffect -= iRAND (goomdata, 8);
+            break;
+          case 4:
+          case 5:
+          case 6:
+          case 7:
+            pzfd->vPlaneEffect = iRAND (goomdata, 5);
+            pzfd->vPlaneEffect -= iRAND (goomdata, 5);
+            pzfd->hPlaneEffect = -pzfd->vPlaneEffect;
+            break;
+          case 8:
+            pzfd->hPlaneEffect = 5 + iRAND (goomdata, 8);
+            pzfd->vPlaneEffect = -pzfd->hPlaneEffect;
+            break;
+          case 9:
+            pzfd->vPlaneEffect = 5 + iRAND (goomdata, 8);
+            pzfd->hPlaneEffect = -pzfd->hPlaneEffect;
+            break;
+          case 13:
+            pzfd->hPlaneEffect = 0;
+            pzfd->vPlaneEffect = iRAND (goomdata, 10);
+            pzfd->vPlaneEffect -= iRAND (goomdata, 10);
+            break;
+          default:
+            if (vtmp < 10) {
+              pzfd->vPlaneEffect = 0;
+              pzfd->hPlaneEffect = 0;
+            }
+        }
+
+        if (iRAND (goomdata, 3) != 0)
+          pzfd->noisify = 0;
+        else {
+          pzfd->noisify = iRAND (goomdata, 3) + 2;
+          goomdata->lockvar *= 3;
+        }
+
+        if (pzfd->mode == AMULETTE_MODE) {
+          pzfd->vPlaneEffect = 0;
+          pzfd->hPlaneEffect = 0;
+          pzfd->noisify = 0;
+        }
+
+        if ((pzfd->middleX == 1) || (pzfd->middleX == resolx - 1)) {
+          pzfd->vPlaneEffect = 0;
+          pzfd->hPlaneEffect = iRAND (goomdata, 2) ? 0 : pzfd->hPlaneEffect;
+        }
+
+        if (newvit < pzfd->vitesse) {   /* on accelere */
+          zfd_update = 1;
+          if (((newvit < STOP_SPEED - 7) &&
+                  (pzfd->vitesse < STOP_SPEED - 6) &&
+                  (goomdata->cycle % 3 == 0)) || (iRAND (goomdata, 40) == 0)) {
+            pzfd->vitesse = STOP_SPEED - 1;
+            pzfd->reverse = !pzfd->reverse;
+          } else {
+            pzfd->vitesse = (newvit + pzfd->vitesse * 4) / 5;
+          }
+          goomdata->lockvar += 50;
+        }
+      }
+    }
+    /* mode mega-lent */
+    if (iRAND (goomdata, 1000) == 0) {
+      /* 
+         printf ("coup du sort...\n") ;
+       */
+      zfd_update = 1;
+      pzfd->vitesse = STOP_SPEED - 1;
+      pzfd->pertedec = 8;
+      pzfd->sqrtperte = 16;
+      goomdata->goomvar = 1;
+      goomdata->lockvar += 70;
+    }
+  }
+
+  /* gros frein si la musique est calme */
+  if ((goomdata->speedvar < 1) && (pzfd->vitesse < STOP_SPEED - 4)
+      && (goomdata->cycle % 16 == 0)) {
+    /*
+       printf ("++slow part... %i\n", zfd.vitesse) ;
+     */
+    zfd_update = 1;
+    pzfd->vitesse += 3;
+    pzfd->pertedec = 8;
+    pzfd->sqrtperte = 16;
+    goomdata->goomvar = 0;
+    /*
+       printf ("--slow part... %i\n", zfd.vitesse) ;
+     */
+  }
+
+  /* baisser regulierement la vitesse... */
+  if ((goomdata->cycle % 73 == 0) && (pzfd->vitesse < STOP_SPEED - 5)) {
+    /*
+       printf ("slow down...\n") ;
+     */
+    zfd_update = 1;
+    pzfd->vitesse++;
+  }
+
+  /* arreter de decrémenter au bout d'un certain temps */
+  if ((goomdata->cycle % 101 == 0) && (pzfd->pertedec == 7)) {
+    zfd_update = 1;
+    pzfd->pertedec = 8;
+    pzfd->sqrtperte = 16;
+  }
+
+  /* Zoom here ! */
+  zoomFilterFastRGB (goomdata, pzfd, zfd_update);
+
+  /* si on est dans un goom : afficher les lignes... */
+  if (goomdata->agoom > 15)
+    goom_lines (goomdata, data, ((pzfd->middleX == resolx / 2)
+            && (pzfd->middleY == resoly / 2)
+            && (pzfd->mode != WATER_MODE))
+        ? (goomdata->lineMode / 10) : 0, goomdata->p2, goomdata->agoom - 15);
+
+  return_val = goomdata->p2;
+  tmp = goomdata->p1;
+  goomdata->p1 = goomdata->p2;
+  goomdata->p2 = tmp;
+
+  /* affichage et swappage des buffers.. */
+  goomdata->cycle++;
+
+  /* tous les 100 cycles : vérifier si le taux de goom est correct */
+  /* et le modifier sinon.. */
+  if (!(goomdata->cycle % 100)) {
+    if (goomdata->totalgoom > 15) {
+      /*  printf ("less gooms\n") ; */
+      goomdata->goomlimit++;
+    } else {
+      if ((goomdata->totalgoom == 0) && (goomdata->goomlimit > 1))
+        goomdata->goomlimit--;
+    }
+    goomdata->totalgoom = 0;
+  }
+  return return_val;
+}
+
+void
+goom_close (GoomData * goomdata)
+{
+  if (goomdata->pixel != NULL)
+    free (goomdata->pixel);
+  if (goomdata->back != NULL)
+    free (goomdata->back);
+  if (goomdata->zfd != NULL) {
+    zoomFilterDestroy (goomdata->zfd);
+    goomdata->zfd = NULL;
+  }
+  goomdata->pixel = goomdata->back = NULL;
+  RAND_CLOSE (goomdata);
+}