Added a goom plugin (goom.sourceforge.net) to test: ./gst-launch filesrc...

Added a goom plugin (goom.sourceforge.net) to test: ./gst-launch filesrc location=/opt/data/south.mp3 ! mad ! tee sil...

Original commit message from CVS:
Added a goom plugin (goom.sourceforge.net)

to test:
./gst-launch filesrc location=/opt/data/south.mp3 ! mad ! tee silent=true src%d! goom ! colorspace ! xvideosink  tee0.src%d! osssink

gst/goom/Makefile.am

+plugindir = $(libdir)/gst
+
+plugin_LTLIBRARIES = libgstgoom.la
+
+libgstgoom_la_SOURCES = gstgoom.c goom_core.c filters.c filters_mmx.s graphic.c lines.c
+
+noinst_HEADERS = filters.h goom_core.h goom_tools.h graphic.h lines.h 
+
+#CFLAGS += -Wall -O3 -fomit-frame-pointer -funroll-all-loops -finline-functions -ffast-math -DNDEBUG
+libgstgoom_la_CFLAGS = -O2 -ffast-math $(GST_CFLAGS) -DMMX
+libgstgoom_la_LIBADD = $(GST_LIBS)
+libgstgoom_la_LDFLAGS = @GST_PLUGIN_LDFLAGS@
+

gst/goom/filters.c

+/* filter.c version 0.7
+ * contient les filtres applicable a un buffer
+ * creation : 01/10/2000
+ *  -ajout de sinFilter()
+ *  -ajout de zoomFilter()
+ *  -copie de zoomFilter() en zoomFilterRGB(), grant les 3 couleurs
+ *  -optimisation de sinFilter (utilisant une table de sin)
+ *	-asm
+ *	-optimisation de la procedure de gnration du buffer de transformation
+ *		la vitesse est maintenant comprise dans [0..128] au lieu de [0..100]
+*/
+
+//#define _DEBUG_PIXEL;
+
+#include "filters.h"
+#include "graphic.h"
+#include "goom_tools.h"
+#include <stdlib.h>
+#include <math.h>
+#include <stdio.h>
+
+#ifdef MMX
+#define USE_ASM
+#endif
+#ifdef POWERPC
+#define USE_ASM
+#endif
+
+#ifdef USE_ASM
+#define EFFECT_DISTORS 4
+#else
+#define EFFECT_DISTORS 10
+#endif
+
+
+extern volatile guint32 resolx;
+extern volatile guint32 resoly;
+
+#ifdef USE_ASM
+
+#ifdef MMX
+int mmx_zoom () ;
+guint32 mmx_zoom_size;
+#endif /* MMX */
+
+#ifdef POWERPC
+extern unsigned int useAltivec;
+extern void ppc_zoom(void);
+extern void ppc_zoom_altivec(void);
+unsigned int ppcsize4;
+#endif /* PowerPC */
+
+unsigned int *coeffs = 0, *freecoeffs = 0;
+guint32 *expix1 = 0; // pointeur exporte vers p1
+guint32 *expix2 = 0; // pointeur exporte vers p2
+guint32 zoom_width;
+
+#endif /* ASM */
+
+
+static int sintable [0xffff] ;
+static int vitesse = 127;
+static char theMode = AMULETTE_MODE ;
+static int vPlaneEffect = 0;
+static int hPlaneEffect = 0;
+static char noisify = 2;
+static int middleX , middleY ;
+static unsigned char sqrtperte = 16 ;
+
+static int * firedec = 0 ;
+
+
+// retourne x>>s , en testant le signe de x
+inline int ShiftRight (int x, const unsigned char s)
+{
+  if (x<0)
+	return -(-x >> s) ;
+  else
+	return x >> s ;
+}
+
+/*
+  calculer px et py en fonction de x,y,middleX,middleY et theMode
+  px et py indique la nouvelle position (en sqrtperte ieme de pixel)
+  (valeur * 16)
+*/
+inline void calculatePXandPY (int x, int y, int *px, int *py)
+{
+    if (theMode == WATER_MODE)
+    {
+        static int wave = 0 ;
+        static int wavesp = 0 ;
+        int yy ;
+
+        yy = y + RAND () % 4 - RAND () % 4 + wave / 10 ;
+        if (yy < 0) yy = 0 ;
+        if (yy >= resoly) yy = resoly - 1 ;
+	  
+        *px = (x<<4) + firedec [yy] + (wave / 10) ;
+        *py = (y<<4) + 132 - ((vitesse < 132) ? vitesse : 131) ;
+
+        wavesp += RAND () % 3 - RAND () % 3 ;
+        if (wave < -10) wavesp += 2 ;
+        if (wave > 10) wavesp -= 2 ;
+        wave += (wavesp / 10) + RAND () % 3 - RAND () % 3 ;
+        if (wavesp > 100) wavesp = (wavesp * 9) / 10  ;
+    }
+    else
+    {
+        int dist ;
+        register int vx,vy ;
+        int fvitesse = vitesse << 4 ;
+
+        if (noisify)
+        {
+            x += RAND() % noisify - RAND() % noisify ;
+            y += RAND() % noisify - RAND() % noisify ;
+        }
+
+        if (hPlaneEffect) vx = ((x - middleX) << 9) + hPlaneEffect * (y - middleY);
+        else vx = (x - middleX) << 9 ;
+	  
+        if (vPlaneEffect) vy = ((y - middleY) << 9) + vPlaneEffect * (x - middleX);
+        else vy = (y - middleY) << 9 ;
+	  
+        switch (theMode)
+        {
+            case WAVE_MODE:
+                dist = ShiftRight(vx,9) * ShiftRight(vx,9) + ShiftRight(vy,9) * ShiftRight(vy,9);
+                fvitesse *= 1024 + ShiftRight (
+                                    sintable [(unsigned short)(0xffff*dist*EFFECT_DISTORS)],6);
+                fvitesse /= 1024 ;
+                break ;
+            case CRYSTAL_BALL_MODE:
+                dist = ShiftRight(vx,9) * ShiftRight(vx,9) + ShiftRight(vy,9) * ShiftRight(vy,9);
+                fvitesse += (dist * EFFECT_DISTORS >> 10);
+                break;
+            case AMULETTE_MODE:
+                dist = ShiftRight(vx,9) * ShiftRight(vx,9) + ShiftRight(vy,9) * ShiftRight(vy,9);
+                fvitesse -= (dist * EFFECT_DISTORS >> 4);
+                break;
+            case SCRUNCH_MODE:
+                dist = ShiftRight(vx,9) * ShiftRight(vx,9) + ShiftRight(vy,9) * ShiftRight(vy,9);
+                fvitesse -= (dist * EFFECT_DISTORS >> 9);
+                break;
+        }
+        if (vx<0) *px = (middleX << 4) - (-(vx * fvitesse) >> 16) ;
+        else *px = (middleX << 4) + ((vx * fvitesse) >> 16) ;
+        if (vy<0) *py = (middleY << 4) - (-(vy * fvitesse) >> 16) ;
+        else *py = (middleY << 4) + ((vy * fvitesse) >> 16) ;
+    }
+}
+
+//#define _DEBUG
+
+inline void setPixelRGB(Uint *buffer, Uint x, Uint y, Color c)
+{
+//		buffer[ y*WIDTH + x ] = (c.r<<16)|(c.v<<8)|c.b
+#ifdef _DEBUG_PIXEL
+  if ( x+y*resolx >= resolx * resoly)
+	{
+	  fprintf (stderr,"setPixel ERROR : hors du tableau... %i, %i\n", x,y) ;
+	  //exit (1) ;
+	}
+#endif
+  
+#ifdef USE_DGA
+  buffer[ y*resolx + x ] = (c.b<<16)|(c.v<<8)|c.r ;
+#else
+  buffer[ y*resolx + x ] = (c.r<<16)|(c.v<<8)|c.b ;
+#endif
+}
+
+
+inline void setPixelRGB_ (Uint *buffer, Uint x, Color c)
+{
+#ifdef _DEBUG
+  if ( x >= resolx*resoly )
+	{
+	  printf ("setPixel ERROR : hors du tableau... %i, %i\n", x,y) ;
+	  exit (1) ;
+	}
+#endif
+  
+#ifdef USE_DGA
+  buffer[ x ] = (c.b<<16)|(c.v<<8)|c.r ;
+#else
+  buffer[ x ] = (c.r<<16)|(c.v<<8)|c.b ;
+#endif
+}
+
+
+
+inline void getPixelRGB (Uint *buffer, Uint x, Uint y, Color *c)
+{
+	register unsigned char *tmp8;
+
+	#ifdef _DEBUG
+	if (x + y * resolx >= resolx*resoly)
+	{
+		printf ("getPixel ERROR : hors du tableau... %i, %i\n", x,y) ;
+		exit (1) ;
+	}
+	#endif
+
+#ifdef __BIG_ENDIAN__
+	c->b = *(unsigned char *)(tmp8 = (unsigned char*)(buffer + (x + y*resolx)));
+    c->r = *(unsigned char *)(++tmp8);
+    c->v = *(unsigned char *)(++tmp8);
+	c->b = *(unsigned char *)(++tmp8);
+			
+#else
+	/* ATTENTION AU PETIT INDIEN  */
+	c->b = *(unsigned char *)(tmp8 = (unsigned char*)(buffer + (x + y*resolx)));
+	c->v = *(unsigned char *)(++tmp8);
+	c->r = *(unsigned char *)(++tmp8);
+//	*c = (Color) buffer[x+y*WIDTH] ;
+#endif
+}
+
+
+inline void getPixelRGB_ (Uint *buffer, Uint x, Color *c)
+{
+	register unsigned char *tmp8;
+
+	#ifdef _DEBUG
+	if ( x >= resolx*resoly )
+	{
+		printf ("getPixel ERROR : hors du tableau... %i\n", x) ;
+		exit (1) ;
+	}
+	#endif
+
+#ifdef __BIG_ENDIAN__
+	c->b = *(unsigned char *)(tmp8 = (unsigned char*)(buffer + x));
+    c->r = *(unsigned char *)(++tmp8);
+    c->v = *(unsigned char *)(++tmp8);
+	c->b = *(unsigned char *)(++tmp8);
+			
+#else
+	/* ATTENTION AU PETIT INDIEN  */
+	c->b = *(unsigned char *)(tmp8 = (unsigned char*)(buffer + x));
+	c->v = *(unsigned char *)(++tmp8);
+	c->r = *(unsigned char *)(++tmp8);
+//	*c = (Color) buffer[x+y*WIDTH] ;
+#endif
+}
+
+
+/*===============================================================*/
+void zoomFilterFastRGB (Uint *pix1,
+						Uint *pix2,
+						ZoomFilterData *zf,
+						Uint resx, Uint resy)
+{
+  static guint32 prevX = 0, prevY = 0;
+
+  static char reverse = 0 ; //vitesse invers..(zoom out)
+  //	static int perte = 100; // 100 = normal
+  static unsigned char pertedec = 8 ;
+  static char firstTime = 1;
+  
+  Uint x, y;
+
+//  static unsigned int prevX = 0, prevY = 0;
+  
+#ifdef USE_ASM
+  expix1 = pix1 ;
+  expix2 = pix2 ;
+#else
+  Color couleur;
+  Color col1,col2,col3,col4;
+  Uint position ;
+
+  static unsigned int *pos10 = 0;
+  static unsigned int *c1 = 0,
+	*c2 = 0,
+	*c3 = 0,
+	*c4 = 0;
+#endif
+  
+  if ((prevX != resx) || (prevY != resy))
+	{
+	  prevX = resx;
+	  prevY = resy;
+#ifndef USE_ASM
+	  if (c1) free (c1) ;
+	  if (c2) free (c2) ;
+	  if (c3) free (c3) ;
+	  if (c4) free (c4) ;
+	  if (pos10) free (pos10) ;
+	  c1=c2=c3=c4=pos10=0;
+#else
+	  if (coeffs) free (freecoeffs) ;
+	  coeffs = 0;
+#endif
+	  middleX = resx / 2 ;
+	  middleY = resy - 1;
+	  firstTime = 1 ;
+	  if (firedec) free (firedec);
+	  firedec=0;
+	}
+	
+	if (zf)
+	  {
+		reverse = zf->reverse ;
+		vitesse = zf->vitesse ;
+		if (reverse)
+		  vitesse = 256 - vitesse ;
+#ifndef USE_ASM
+		sqrtperte = zf->sqrtperte ;
+#endif
+		pertedec = zf->pertedec ;
+		middleX = zf->middleX ;
+		middleY = zf->middleY ;
+		theMode = zf->mode ;
+		hPlaneEffect = zf->hPlaneEffect;
+		vPlaneEffect = zf->vPlaneEffect;
+		noisify = zf->noisify;
+	  }
+	
+	if (firstTime || zf)
+	  {
+		
+		// generation d'une table de sinus
+		if (firstTime)
+		  {
+			unsigned short us ;
+
+			firstTime = 0;
+#ifdef USE_ASM
+			freecoeffs = (unsigned int *)
+			  malloc (resx*resy*2*sizeof(unsigned int)+128);
+                        coeffs = (guint32 *)((1+((unsigned int)(freecoeffs))/128)*128);
+
+#else
+			pos10 = (unsigned int *) malloc (resx*resy*sizeof(unsigned int)) ;
+			c1 = (unsigned int *) malloc (resx*resy*sizeof(unsigned int)) ;
+			c2 = (unsigned int *) malloc (resx*resy*sizeof(unsigned int)) ;
+			c3 = (unsigned int *) malloc (resx*resy*sizeof(unsigned int)) ;
+			c4 = (unsigned int *) malloc (resx*resy*sizeof(unsigned int)) ;
+#endif
+			for (us=0; us<0xffff; us++)
+			  {
+				sintable [us] = (int)(1024.0f * sin (us*2*3.31415f/0xffff)) ;
+			  }
+			
+			{
+			  int loopv ;
+			  firedec = (int *) malloc (prevY * sizeof(int)) ;
+			  for (loopv = prevY ; loopv != 0 ;)
+				{
+				  static int decc = 0 ;
+				  static int spdc = 0 ;
+				  static int accel = 0 ;
+				  loopv -- ;
+				  firedec [loopv] = decc ;
+				  decc += spdc / 10 ;
+				  spdc = spdc + RAND () % 3 - RAND () % 3 ;
+				  
+				  if (decc > 4)
+					spdc -= 1 ;
+				  if (decc < -4)
+					spdc += 1 ;
+				  
+				  if (spdc > 30)
+					spdc = spdc - RAND () % 3 + accel / 10 ;
+				  if (spdc < -30)
+					spdc = spdc + RAND () % 3 + accel / 10 ;
+				  
+				  if (decc > 8 && spdc > 1 )
+					spdc -= RAND () % 3 - 2 ;
+				  
+				  if (decc < -8 && spdc < -1 )
+					spdc += RAND () % 3 + 2 ;
+				  
+				  if (decc > 8 || decc < -8)
+					decc = decc * 8 / 9 ;
+				  
+				  accel += RAND () % 2 - RAND () % 2 ;
+				  if (accel > 20)
+					accel -= 2 ;
+				  if (accel < -20)
+					accel += 2 ;
+				}
+			}
+		  }
+		
+		
+		// generation du buffer
+		for (y = 0 ; y < prevY ; y++)
+		  for (x = 0; x < prevX ; x++)
+			{
+			  int px,py;
+			  unsigned char coefv,coefh;
+			  
+			  // calculer px et py en fonction de
+			  //   x,y,middleX,middleY et theMode
+			  calculatePXandPY (x,y,&px, &py) ;
+			  if ((px == x << 4) && (py == y << 4))
+				py += 8 ;
+
+			  if ( (py<0) || (px<0) ||
+				   (py>=(prevY-1)*sqrtperte) ||
+				   (px>=(prevX-1)*sqrtperte))
+				{
+#ifdef USE_ASM
+				  coeffs[(y*prevX+x)*2]=0 ;
+				  coeffs[(y*prevX+x)*2+1]=0;
+#else
+				  pos10[y*prevX+x]=0 ;
+				  c1[y*prevX+x] = 0 ;
+				  c2[y*prevX+x] = 0 ;
+				  c3[y*prevX+x] = 0 ;
+				  c4[y*prevX+x] = 0 ;
+#endif
+				}
+			  else
+				{
+				  int npx10 ;
+				  int npy10 ;
+                                  int pos = (y*prevX+x)*2;
+
+				  npx10 = (px/sqrtperte) ;
+				  npy10 = (py/sqrtperte) ;
+                                  
+/*			  if (npx10 >= prevX) fprintf(stderr,"error npx:%d",npx10);
+			  if (npy10 >= prevY) fprintf(stderr,"error npy:%d",npy10);
+*/				  
+				  coefh = px % sqrtperte ;
+				  coefv = py % sqrtperte ;				  
+#ifdef USE_ASM
+                                coeffs[pos] = (npx10 + prevX * npy10) * 4;
+				
+				if (!(coefh || coefv))
+				  coeffs[pos+1] = (sqrtperte*sqrtperte-1) ;
+				else
+				  coeffs[pos+1] = (
+					(sqrtperte-coefh) *
+					(sqrtperte-coefv) );
+				
+				coeffs[pos+1] |= (coefh * (sqrtperte-coefv)) << 8 ;
+				coeffs[pos+1] |= ((sqrtperte-coefh) * coefv) << 16 ;
+				coeffs[pos+1] |= (coefh * coefv)<<24 ;
+#else
+				pos10[y*prevX+x]= npx10 + prevX * npy10 ;
+
+				if (!(coefh || coefv))
+					c1[y*prevX+x] = sqrtperte*sqrtperte-1 ;
+				else
+					c1[y*prevX+x] = (sqrtperte-coefh) * (sqrtperte-coefv);
+				
+				c2[y*prevX+x] = coefh * (sqrtperte-coefv) ;
+				c3[y*prevX+x] = (sqrtperte-coefh) * coefv ;
+				c4[y*prevX+x] = coefh * coefv ;
+#endif
+				}
+			}
+	  }
+	
+#ifdef USE_ASM
+
+        #ifdef MMX
+	zoom_width = prevX ;
+	mmx_zoom_size = prevX * prevY ;
+        mmx_zoom () ;
+        #endif
+        
+        #ifdef POWERPC
+        zoom_width = prevX;
+        if (useAltivec)
+        {
+            ppcsize4 = ((unsigned int)(prevX*prevY))/4;
+            ppc_zoom_altivec();
+        }
+        else
+        {
+            ppcsize4 = ((unsigned int)(prevX*prevY));
+            ppc_zoom();        
+        }
+        #endif
+#else
+	for (position=0; position<prevX*prevY; position++)
+	  {
+		getPixelRGB_(pix1,pos10[position],&col1);
+		getPixelRGB_(pix1,pos10[position]+1,&col2);
+		getPixelRGB_(pix1,pos10[position]+prevX,&col3);
+		getPixelRGB_(pix1,pos10[position]+prevX+1,&col4);
+		
+		couleur.r = col1.r * c1[position]
+                    + col2.r * c2[position]
+                    + col3.r * c3[position]
+                    + col4.r * c4[position];
+		couleur.r >>= pertedec ;
+
+		couleur.v = col1.v * c1[position]
+                    + col2.v * c2[position]
+                    + col3.v * c3[position]
+                    + col4.v * c4[position];
+		couleur.v >>= pertedec ;
+		
+		couleur.b = col1.b * c1[position]
+                    + col2.b * c2[position]
+                    + col3.b * c3[position]
+                    + col4.b * c4[position];
+		couleur.b >>= pertedec ;
+		
+		setPixelRGB_(pix2,position,couleur);
+	}
+#endif
+}
+
+
+void pointFilter(Uint *pix1, Color c,
+				 float t1, float t2, float t3, float t4,
+				 Uint cycle)
+{
+  Uint x = (Uint)((int)middleX + (int)(t1*cos((float)cycle/t3)));
+  Uint y = (Uint)((int)middleY + (int)(t2*sin((float)cycle/t4)));
+  if ((x>1) && (y>1) && (x<resolx-2) && (y<resoly-2))
+	{
+	  setPixelRGB(pix1, x+1, y, c);
+	  setPixelRGB(pix1, x, y+1, c);
+	  setPixelRGB(pix1, x+1, y+1, WHITE);
+	  setPixelRGB(pix1, x+2, y+1, c);
+	  setPixelRGB(pix1, x+1, y+2, c);
+	}
+}

gst/goom/filters.h

+#ifndef FILTERS_H
+#define FILTERS_H
+
+#include <glib.h>
+
+#include "graphic.h"
+
+typedef struct
+{
+	int vitesse ;
+	unsigned char pertedec ;
+	unsigned char sqrtperte ;
+	int middleX,middleY ;
+	char reverse ;
+	char mode ;
+	/** @since June 2001 */
+	int hPlaneEffect ;
+	int vPlaneEffect ;
+	char noisify ;
+} ZoomFilterData ;
+
+
+#define NORMAL_MODE 0
+#define WAVE_MODE 1
+#define CRYSTAL_BALL_MODE 2
+#define SCRUNCH_MODE 3
+#define AMULETTE_MODE 4
+#define WATER_MODE 5
+
+void pointFilter(guint32 *pix1, Color c,
+				 float t1, float t2, float t3, float t4,
+				 guint32 cycle);
+
+/* filtre de zoom :
+ le contenu de pix1 est copie dans pix2, avec l'effet appliqu
+ midx et midy represente le centre du zoom
+
+void zoomFilter(Uint *pix1, Uint *pix2, Uint middleX, Uint middleY);
+void zoomFilterRGB(Uint *pix1,
+Uint *pix2,
+Uint middleX,
+Uint middleY);
+*/
+
+void zoomFilterFastRGB (guint32 *pix1,
+						guint32 *pix2,
+						ZoomFilterData *zf,
+						guint32 resx, guint32 resy);
+
+
+/* filtre sin :
+ le contenu de pix1 est copie dans pix2, avec l'effet appliqu
+ cycle est la variable de temps.
+ mode vaut SIN_MUL ou SIN_ADD
+ rate est le pourcentage de l'effet appliqu
+ lenght : la longueur d'onde (1..10) [5]
+ speed : la vitesse (1..100) [10]
+*/
+/*
+void sinFilter(Uint *pix1,Uint *pix2,
+			   Uint cycle,
+			   Uint mode,
+			   Uint rate,
+			   char lenght,
+			   Uint speed);
+*/
+
+#define SIN_MUL 1
+#define SIN_ADD 2
+
+#endif

gst/goom/filters_mmx.s

+;// file : mmx_zoom.s
+;// author : JC Hoelt <jeko@free.fr>