From 07c1dceae064b547747a1513ca17225c1c1c3e0e Mon Sep 17 00:00:00 2001 From: Jan Schmidt Date: Sun, 5 Feb 2006 20:43:49 +0000 Subject: gst/goom/: Make goom reentrant by moving all important static variables into instance structures. Original commit message from CVS: * gst/goom/filters.c: (zoomFilterNew), (calculatePXandPY), (setPixelRGB), (setPixelRGB_), (getPixelRGB), (getPixelRGB_), (zoomFilterSetResolution), (zoomFilterDestroy), (zoomFilterFastRGB), (pointFilter): * gst/goom/filters.h: * gst/goom/goom_core.c: (goom_init), (goom_set_resolution), (goom_update), (goom_close): * gst/goom/goom_core.h: * gst/goom/goom_tools.h: * gst/goom/graphic.c: * gst/goom/gstgoom.c: (gst_goom_class_init), (gst_goom_init), (gst_goom_dispose), (gst_goom_src_setcaps), (gst_goom_chain): * gst/goom/gstgoom.h: * gst/goom/lines.c: (goom_lines): * gst/goom/lines.h: Make goom reentrant by moving all important static variables into instance structures. (Fixes #329181) --- gst/goom/filters.c | 467 ++++++++++++++++++++++++++++---------------------- gst/goom/filters.h | 54 +++--- gst/goom/goom_core.c | 408 +++++++++++++++++++++---------------------- gst/goom/goom_core.h | 38 +++- gst/goom/goom_tools.h | 31 ++-- gst/goom/graphic.c | 7 - gst/goom/gstgoom.c | 8 +- gst/goom/gstgoom.h | 3 + gst/goom/lines.c | 8 +- gst/goom/lines.h | 5 +- 10 files changed, 556 insertions(+), 473 deletions(-) (limited to 'gst/goom') diff --git a/gst/goom/filters.c b/gst/goom/filters.c index f92dbcd7..ee598100 100644 --- a/gst/goom/filters.c +++ b/gst/goom/filters.c @@ -19,6 +19,7 @@ #include "filters.h" #include "graphic.h" #include "goom_tools.h" +#include "goom_core.h" #include #include #include @@ -37,9 +38,6 @@ #endif -extern volatile guint32 resolx; -extern volatile guint32 resoly; - #ifdef USE_ASM #ifdef MMX @@ -54,25 +52,44 @@ 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 firstTime = 1; 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; +ZoomFilterData * +zoomFilterNew () +{ + ZoomFilterData *zf = malloc (sizeof (ZoomFilterData)); + + zf->vitesse = 128; + zf->pertedec = 8; + zf->sqrtperte = 16; + zf->middleX = 1; + zf->middleY = 1; + zf->reverse = 0; + zf->mode = WAVE_MODE; + zf->hPlaneEffect = 0; + zf->vPlaneEffect = 0; + zf->noisify = 0; + zf->buffsize = 0; + zf->res_x = 0; + zf->res_y = 0; + + zf->buffer = NULL; + zf->firedec = NULL; + + zf->wave = 0; + zf->wavesp = 0; + + return zf; +} /* retourne x>>s , en testant le signe de x */ static inline int @@ -90,43 +107,56 @@ ShiftRight (int x, const unsigned char s) (valeur * 16) */ void -calculatePXandPY (int x, int y, int *px, int *py) +calculatePXandPY (GoomData * gd, int x, int y, int *px, int *py) { + ZoomFilterData *zf = gd->zfd; + int middleX, middleY; + guint32 resoly = zf->res_y; + int vPlaneEffect = zf->vPlaneEffect; + int hPlaneEffect = zf->hPlaneEffect; + int vitesse = zf->vitesse; + char theMode = zf->mode; + if (theMode == WATER_MODE) { - static int wave = 0; - static int wavesp = 0; - int yy; + int wavesp = zf->wavesp; + int wave = zf->wave; + int yy = y + RAND (gd) % 4 + wave / 10; - yy = y + RAND () % 4 + wave / 10; - yy -= RAND () % 4; + yy -= RAND (gd) % 4; if (yy < 0) yy = 0; if (yy >= resoly) yy = resoly - 1; - *px = (x << 4) + firedec[yy] + (wave / 10); + *px = (x << 4) + zf->firedec[yy] + (wave / 10); *py = (y << 4) + 132 - ((vitesse < 132) ? vitesse : 131); - wavesp += RAND () % 3; - wavesp -= RAND () % 3; + wavesp += RAND (gd) % 3; + wavesp -= RAND (gd) % 3; if (wave < -10) wavesp += 2; if (wave > 10) wavesp -= 2; - wave += (wavesp / 10) + RAND () % 3; - wave -= RAND () % 3; + wave += (wavesp / 10) + RAND (gd) % 3; + wave -= RAND (gd) % 3; if (wavesp > 100) wavesp = (wavesp * 9) / 10; + + zf->wavesp = wavesp; + zf->wave = wave; } else { int dist; register int vx, vy; int fvitesse = vitesse << 4; - if (noisify) { - x += RAND () % noisify; - x -= RAND () % noisify; - y += RAND () % noisify; - y -= RAND () % noisify; + middleX = zf->middleX; + middleY = zf->middleY; + + if (zf->noisify) { + x += RAND (gd) % zf->noisify; + x -= RAND (gd) % zf->noisify; + y += RAND (gd) % zf->noisify; + y -= RAND (gd) % zf->noisify; } if (hPlaneEffect) @@ -183,7 +213,8 @@ calculatePXandPY (int x, int y, int *px, int *py) /*#define _DEBUG */ static inline void -setPixelRGB (Uint * buffer, Uint x, Uint y, Color c) +setPixelRGB (Uint * buffer, Uint x, Uint y, Color c, + guint32 resolx, guint32 resoly) { /* buffer[ y*WIDTH + x ] = (c.r<<16)|(c.v<<8)|c.b */ #ifdef _DEBUG_PIXEL @@ -202,7 +233,7 @@ setPixelRGB (Uint * buffer, Uint x, Uint y, Color c) static inline void -setPixelRGB_ (Uint * buffer, Uint x, Color c) +setPixelRGB_ (Uint * buffer, Uint x, Color c, guint32 resolx, guint32 resoly) { #ifdef _DEBUG if (x >= resolx * resoly) { @@ -221,7 +252,8 @@ setPixelRGB_ (Uint * buffer, Uint x, Color c) static inline void -getPixelRGB (Uint * buffer, Uint x, Uint y, Color * c) +getPixelRGB (Uint * buffer, Uint x, Uint y, Color * c, + guint32 resolx, guint32 resoly) { register unsigned char *tmp8; @@ -251,7 +283,7 @@ getPixelRGB (Uint * buffer, Uint x, Uint y, Color * c) static inline void -getPixelRGB_ (Uint * buffer, Uint x, Color * c) +getPixelRGB_ (Uint * buffer, Uint x, Color * c, guint32 resolx, guint32 resoly) { register unsigned char *tmp8; @@ -270,26 +302,132 @@ getPixelRGB_ (Uint * buffer, Uint x, Color * c) #else /* ATTENTION AU PETIT INDIEN */ - c->b = *(unsigned char *) (tmp8 = (unsigned char *) (buffer + x)); - c->v = *(unsigned char *) (++tmp8); - c->r = *(unsigned char *) (++tmp8); + tmp8 = (unsigned char *) (buffer + x); + c->b = *(unsigned char *) (tmp8++); + c->v = *(unsigned char *) (tmp8++); + c->r = *(unsigned char *) (tmp8); /* *c = (Color) buffer[x+y*WIDTH] ; */ #endif } +static void +zoomFilterSetResolution (GoomData * gd, ZoomFilterData * zf) +{ + unsigned short us; + + if (zf->buffsize >= gd->buffsize) { + zf->res_x = gd->resolx; + zf->res_y = gd->resoly; + zf->middleX = gd->resolx / 2; + zf->middleY = gd->resoly - 1; + + return; + } +#ifndef USE_ASM + if (zf->buffer) + free (zf->buffer); + zf->buffer = 0; +#else + if (coeffs) + free (freecoeffs); + coeffs = 0; +#endif + zf->middleX = gd->resolx / 2; + zf->middleY = gd->resoly - 1; + zf->res_x = gd->resolx; + zf->res_y = gd->resoly; + + if (zf->firedec) + free (zf->firedec); + zf->firedec = 0; + + zf->buffsize = gd->resolx * gd->resoly * sizeof (unsigned int); + +#ifdef USE_ASM + freecoeffs = (unsigned int *) + malloc (resx * resy * 2 * sizeof (unsigned int) + 128); + coeffs = (guint32 *) ((1 + ((unsigned int) (freecoeffs)) / 128) * 128); + +#else + zf->buffer = malloc (sizeof (guint32) * zf->buffsize * 5); + zf->pos10 = zf->buffer; + zf->c[0] = zf->pos10 + zf->buffsize; + zf->c[1] = zf->c[0] + zf->buffsize; + zf->c[2] = zf->c[1] + zf->buffsize; + zf->c[3] = zf->c[2] + zf->buffsize; +#endif + zf->firedec = (int *) malloc (zf->res_y * sizeof (int)); + + if (firstTime) { + firstTime = 0; + + /* generation d'une table de sinus */ + for (us = 0; us < 0xffff; us++) { + sintable[us] = (int) (1024.0f * sin (us * 2 * 3.31415f / 0xffff)); + } + } + + { + int loopv; + + for (loopv = zf->res_y; loopv != 0;) { + int decc = 0; + int spdc = 0; + int accel = 0; + + loopv--; + zf->firedec[loopv] = decc; + decc += spdc / 10; + spdc += RAND (gd) % 3; + spdc -= RAND (gd) % 3; + + if (decc > 4) + spdc -= 1; + if (decc < -4) + spdc += 1; + + if (spdc > 30) + spdc = spdc - RAND (gd) % 3 + accel / 10; + if (spdc < -30) + spdc = spdc + RAND (gd) % 3 + accel / 10; + + if (decc > 8 && spdc > 1) + spdc -= RAND (gd) % 3 - 2; + + if (decc < -8 && spdc < -1) + spdc += RAND (gd) % 3 + 2; + + if (decc > 8 || decc < -8) + decc = decc * 8 / 9; + + accel += RAND (gd) % 2; + accel -= RAND (gd) % 2; + if (accel > 20) + accel -= 2; + if (accel < -20) + accel += 2; + } + } +} -/*===============================================================*/ void -zoomFilterFastRGB (Uint * pix1, - Uint * pix2, ZoomFilterData * zf, Uint resx, Uint resy) +zoomFilterDestroy (ZoomFilterData * zf) { - static guint32 prevX = 0, prevY = 0; + if (zf) + free (zf); +} - static char reverse = 0; /*vitesse inversé..(zoom out) */ +/*===============================================================*/ +void +zoomFilterFastRGB (GoomData * goomdata, ZoomFilterData * zf, int zfd_update) +{ + guint32 prevX = goomdata->resolx; + guint32 prevY = goomdata->resoly; - /* static int perte = 100; // 100 = normal */ - static unsigned char pertedec = 8; - static char firstTime = 1; + guint32 *pix1 = goomdata->p1; + guint32 *pix2 = goomdata->p2; + unsigned int *pos10; + unsigned int **c; Uint x, y; @@ -302,147 +440,49 @@ zoomFilterFastRGB (Uint * pix1, 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 ((goomdata->resolx != zf->res_x) || (goomdata->resoly != zf->res_y)) { + zoomFilterSetResolution (goomdata, zf); } - 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; - } + pos10 = zf->pos10; + c = zf->c; - 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 += RAND () % 3; - spdc -= 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; - accel -= RAND () % 2; - if (accel > 20) - accel -= 2; - if (accel < -20) - accel += 2; - } - } - } + if (zfd_update) { + guchar sqrtperte = zf->sqrtperte; + gint start_y = 0; + if (zf->reverse) + zf->vitesse = 256 - zf->vitesse; /* generation du buffer */ - for (y = 0; y < prevY; y++) - for (x = 0; x < prevX; x++) { - int px, py; - unsigned char coefv, coefh; + for (y = 0; y < zf->res_y; y++) { + gint y_16 = y << 4; + gint max_px = (prevX - 1) * sqrtperte; + gint max_py = (prevY - 1) * sqrtperte; + + for (x = 0; x < zf->res_x; x++) { + gint px, py; + guchar 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)) + calculatePXandPY (goomdata, x, y, &px, &py); + + if ((px == x << 4) && (py == y_16)) py += 8; - if ((py < 0) || (px < 0) || - (py >= (prevY - 1) * sqrtperte) || - (px >= (prevX - 1) * sqrtperte)) { + if ((py < 0) || (px < 0) || (py >= max_py) || (px >= max_px)) { #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; + pos10[start_y + x] = 0; + c[0][start_y + x] = 0; + c[1][start_y + x] = 0; + c[2][start_y + x] = 0; + c[3][start_y + x] = 0; #endif } else { int npx10; @@ -470,23 +510,25 @@ zoomFilterFastRGB (Uint * pix1, coeffs[pos + 1] |= ((sqrtperte - coefh) * coefv) << 16; coeffs[pos + 1] |= (coefh * coefv) << 24; #else - pos = y * prevX + x; + pos = start_y + x; pos10[pos] = npx10 + prevX * npy10; if (!(coefh || coefv)) - c1[pos] = sqrtperte * sqrtperte - 1; + c[0][pos] = sqrtperte * sqrtperte - 1; else - c1[pos] = (sqrtperte - coefh) * (sqrtperte - coefv); + c[0][pos] = (sqrtperte - coefh) * (sqrtperte - coefv); - c2[pos] = coefh * (sqrtperte - coefv); - c3[pos] = (sqrtperte - coefh) * coefv; - c4[pos] = coefh * coefv; + c[1][pos] = coefh * (sqrtperte - coefv); + c[2][pos] = (sqrtperte - coefh) * coefv; + c[3][pos] = coefh * coefv; #endif } } + /* Advance start of line index */ + start_y += prevX; + } } #ifdef USE_ASM - #ifdef MMX zoom_width = prevX; mmx_zoom_size = prevX * prevY; @@ -505,47 +547,54 @@ zoomFilterFastRGB (Uint * pix1, #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); + getPixelRGB_ (pix1, pos10[position], &col1, goomdata->resolx, + goomdata->resoly); + getPixelRGB_ (pix1, pos10[position] + 1, &col2, goomdata->resolx, + goomdata->resoly); + getPixelRGB_ (pix1, pos10[position] + prevX, &col3, goomdata->resolx, + goomdata->resoly); + getPixelRGB_ (pix1, pos10[position] + prevX + 1, &col4, goomdata->resolx, + goomdata->resoly); + + couleur.r = col1.r * c[0][position] + + col2.r * c[1][position] + + col3.r * c[2][position] + + col4.r * c[3][position]; + couleur.r >>= zf->pertedec; + + couleur.v = col1.v * c[0][position] + + col2.v * c[1][position] + + col3.v * c[2][position] + + col4.v * c[3][position]; + couleur.v >>= zf->pertedec; + + couleur.b = col1.b * c[0][position] + + col2.b * c[1][position] + + col3.b * c[2][position] + + col4.b * c[3][position]; + couleur.b >>= zf->pertedec; + + setPixelRGB_ (pix2, position, couleur, goomdata->resolx, goomdata->resoly); } #endif } void -pointFilter (Uint * pix1, Color c, +pointFilter (GoomData * goomdata, 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); + Uint *pix1 = goomdata->p1; + ZoomFilterData *zf = goomdata->zfd; + Uint x = (Uint) (zf->middleX + (int) (t1 * cos ((float) cycle / t3))); + Uint y = (Uint) (zf->middleY + (int) (t2 * sin ((float) cycle / t4))); + + if ((x > 1) && (y > 1) && (x < goomdata->resolx - 2) + && (y < goomdata->resoly - 2)) { + setPixelRGB (pix1, x + 1, y, c, goomdata->resolx, goomdata->resoly); + setPixelRGB (pix1, x, y + 1, c, goomdata->resolx, goomdata->resoly); + setPixelRGB (pix1, x + 1, y + 1, WHITE, goomdata->resolx, goomdata->resoly); + setPixelRGB (pix1, x + 2, y + 1, c, goomdata->resolx, goomdata->resoly); + setPixelRGB (pix1, x + 1, y + 2, c, goomdata->resolx, goomdata->resoly); } } diff --git a/gst/goom/filters.h b/gst/goom/filters.h index dac34dd9..65eb3e25 100644 --- a/gst/goom/filters.h +++ b/gst/goom/filters.h @@ -4,21 +4,7 @@ #include #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 ; - +#include "goom_core.h" #define NORMAL_MODE 0 #define WAVE_MODE 1 @@ -27,7 +13,34 @@ typedef struct #define AMULETTE_MODE 4 #define WATER_MODE 5 -void pointFilter(guint32 *pix1, Color c, +struct ZoomFilterData +{ + int vitesse; + unsigned char pertedec; + unsigned char sqrtperte; + int middleX; + int middleY; + char reverse; + char mode; + /** @since June 2001 */ + int hPlaneEffect; + int vPlaneEffect; + char noisify; + + guint32 res_x; + guint32 res_y; + guint32 buffsize; + + guint32 *buffer; + guint32 *pos10; + guint32 *c[4]; + int *firedec; + + int wave; + int wavesp; +}; + +void pointFilter(GoomData *goomdata, Color c, float t1, float t2, float t3, float t4, guint32 cycle); @@ -42,11 +55,10 @@ Uint middleX, Uint middleY); */ -void zoomFilterFastRGB (guint32 *pix1, - guint32 *pix2, - ZoomFilterData *zf, - guint32 resx, guint32 resy); - +ZoomFilterData *zoomFilterNew (); +void zoomFilterDestroy (ZoomFilterData *zf); +void zoomFilterFastRGB (GoomData *goomdata, ZoomFilterData *zf, + int zfd_update); /* filtre sin : le contenu de pix1 est copie dans pix2, avec l'effet appliqué diff --git a/gst/goom/goom_core.c b/gst/goom/goom_core.c index 644ff0a6..1734a316 100644 --- a/gst/goom/goom_core.c +++ b/gst/goom/goom_core.c @@ -1,3 +1,8 @@ +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif +#include + #include #include #include "goom_core.h" @@ -13,67 +18,69 @@ #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) +goom_init (GoomData * goomdata, 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)); + 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 (guint32 resx, guint32 resy) +goom_set_resolution (GoomData * goomdata, guint32 resx, guint32 resy) { - free (pixel); - free (back); - - resolx = resx; - resoly = resy; - buffsize = resx * 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)); + } - 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); + goomdata->resolx = resx; + goomdata->resoly = resy; - p1 = (void *) (((unsigned long) pixel + 0x7f) & (~0x7f)); - p2 = (void *) (((unsigned long) back + 0x7f) & (~0x7f)); + memset (goomdata->pixel, 0, buffsize * sizeof (guint32) + 128); + memset (goomdata->back, 0, buffsize * sizeof (guint32) + 128); } - guint32 * -goom_update (gint16 data[2][512]) +goom_update (GoomData * goomdata, 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; @@ -81,16 +88,14 @@ goom_update (gint16 data[2][512]) 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; + 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; @@ -102,308 +107,303 @@ goom_update (gint16 data[2][512]) } accelvar = incvar / 5000; - if (speedvar > 5) { + if (goomdata->speedvar > 5) { accelvar--; - if (speedvar > 20) + if (goomdata->speedvar > 20) accelvar--; - if (speedvar > 40) - speedvar = 40; + if (goomdata->speedvar > 40) + goomdata->speedvar = 40; } accelvar--; - speedvar += accelvar; + goomdata->speedvar += accelvar; - if (speedvar < 0) - speedvar = 0; - if (speedvar > 40) - speedvar = 40; + if (goomdata->speedvar < 0) + goomdata->speedvar = 0; + if (goomdata->speedvar > 40) + goomdata->speedvar = 40; /* ! calcul du deplacement des petits points ... */ - largfactor = ((float) speedvar / 40.0f + (float) incvar / 50000.0f) / 1.5f; + largfactor = + ((float) goomdata->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; + for (i = 1; i * 15 <= goomdata->speedvar + 15; i++) { + goomdata->loopvar += goomdata->speedvar + 1; - pointFilter (p1, + pointFilter (goomdata, YELLOW, ((pointWidth - 6.0f) * largfactor + 5.0f), ((pointHeight - 6.0f) * largfactor + 5.0f), - i * 152.0f, 128.0f, loopvar + i * 2032); - pointFilter (p1, ORANGE, + 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, loopvar / i); - pointFilter (p1, VIOLET, + 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, loopvar / i); - pointFilter (p1, BLACK, + 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, loopvar / i); - pointFilter (p1, WHITE, + 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, loopvar + i * 500); + 66.0f, 74.0f, goomdata->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; + if (--goomdata->lockvar < 0) + goomdata->lockvar = 0; /* temps du goom */ - if (--agoom < 0) - agoom = 0; + if (--goomdata->agoom < 0) + goomdata->agoom = 0; /* on verifie qu'il ne se pas un truc interressant avec le son. */ - if ((accelvar > goomlimit) || (accelvar < -goomlimit)) { + if ((accelvar > goomdata->goomlimit) || (accelvar < -goomdata->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 */ + 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 (10)) { + switch (iRAND (goomdata, 10)) { case 0: case 1: case 2: - zfd.mode = WAVE_MODE; - zfd.vitesse = STOP_SPEED - 1; - zfd.reverse = 0; + pzfd->mode = WAVE_MODE; + pzfd->vitesse = STOP_SPEED - 1; + pzfd->reverse = 0; break; case 3: case 4: - zfd.mode = CRYSTAL_BALL_MODE; + pzfd->mode = CRYSTAL_BALL_MODE; break; case 5: - zfd.mode = AMULETTE_MODE; + pzfd->mode = AMULETTE_MODE; break; case 6: - zfd.mode = WATER_MODE; + pzfd->mode = WATER_MODE; break; case 7: - zfd.mode = SCRUNCH_MODE; + pzfd->mode = SCRUNCH_MODE; break; default: - zfd.mode = NORMAL_MODE; + pzfd->mode = NORMAL_MODE; } } /* tout ceci ne sera fait qu'en cas de non-blocage */ - if (lockvar == 0) { + if (goomdata->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 ((accelvar > goomdata->goomlimit) || (accelvar < -goomdata->goomlimit)) { + goomdata->goomvar++; /*if (goomvar % 1 == 0) */ { guint32 vtmp; guint32 newvit; - newvit = STOP_SPEED - speedvar / 2; + newvit = STOP_SPEED - goomdata->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 ((pzfd->reverse) && (!(goomdata->cycle % 12)) && (rand () % 3 == 0)) { + pzfd->reverse = 0; + pzfd->vitesse = STOP_SPEED - 2; + goomdata->lockvar = 50; } - if (iRAND (10) == 0) { - zfd.reverse = 1; - lockvar = 100; + if (iRAND (goomdata, 10) == 0) { + pzfd->reverse = 1; + goomdata->lockvar = 100; } /* changement de milieu.. */ - switch (iRAND (20)) { + switch (iRAND (goomdata, 20)) { case 0: - zfd.middleY = resoly - 1; - zfd.middleX = resolx / 2; + pzfd->middleY = resoly - 1; + pzfd->middleX = resolx / 2; break; case 1: - zfd.middleX = resolx - 1; + pzfd->middleX = resolx - 1; break; case 2: - zfd.middleX = 1; + pzfd->middleX = 1; break; default: - zfd.middleY = resoly / 2; - zfd.middleX = resolx / 2; + pzfd->middleY = resoly / 2; + pzfd->middleX = resolx / 2; } - if (zfd.mode == WATER_MODE) { - zfd.middleX = resolx / 2; - zfd.middleY = resoly / 2; + if (pzfd->mode == WATER_MODE) { + pzfd->middleX = resolx / 2; + pzfd->middleY = resoly / 2; } - switch (vtmp = (iRAND (27))) { + switch (vtmp = (iRAND (goomdata, 27))) { case 0: - zfd.vPlaneEffect = iRAND (3); - zfd.vPlaneEffect -= iRAND (3); - zfd.hPlaneEffect = iRAND (3); - zfd.hPlaneEffect -= iRAND (3); + pzfd->vPlaneEffect = iRAND (goomdata, 3); + pzfd->vPlaneEffect -= iRAND (goomdata, 3); + pzfd->hPlaneEffect = iRAND (goomdata, 3); + pzfd->hPlaneEffect -= iRAND (goomdata, 3); break; case 3: - zfd.vPlaneEffect = 0; - zfd.hPlaneEffect = iRAND (8); - zfd.hPlaneEffect -= iRAND (8); + pzfd->vPlaneEffect = 0; + pzfd->hPlaneEffect = iRAND (goomdata, 8); + pzfd->hPlaneEffect -= iRAND (goomdata, 8); break; case 4: case 5: case 6: case 7: - zfd.vPlaneEffect = iRAND (5); - zfd.vPlaneEffect -= iRAND (5); - zfd.hPlaneEffect = -zfd.vPlaneEffect; + pzfd->vPlaneEffect = iRAND (goomdata, 5); + pzfd->vPlaneEffect -= iRAND (goomdata, 5); + pzfd->hPlaneEffect = -pzfd->vPlaneEffect; break; case 8: - zfd.hPlaneEffect = 5 + iRAND (8); - zfd.vPlaneEffect = -zfd.hPlaneEffect; + pzfd->hPlaneEffect = 5 + iRAND (goomdata, 8); + pzfd->vPlaneEffect = -pzfd->hPlaneEffect; break; case 9: - zfd.vPlaneEffect = 5 + iRAND (8); - zfd.hPlaneEffect = -zfd.hPlaneEffect; + pzfd->vPlaneEffect = 5 + iRAND (goomdata, 8); + pzfd->hPlaneEffect = -pzfd->hPlaneEffect; break; case 13: - zfd.hPlaneEffect = 0; - zfd.vPlaneEffect = iRAND (10); - zfd.vPlaneEffect -= iRAND (10); + pzfd->hPlaneEffect = 0; + pzfd->vPlaneEffect = iRAND (goomdata, 10); + pzfd->vPlaneEffect -= iRAND (goomdata, 10); break; default: if (vtmp < 10) { - zfd.vPlaneEffect = 0; - zfd.hPlaneEffect = 0; + pzfd->vPlaneEffect = 0; + pzfd->hPlaneEffect = 0; } } - if (iRAND (3) != 0) - zfd.noisify = 0; + if (iRAND (goomdata, 3) != 0) + pzfd->noisify = 0; else { - zfd.noisify = iRAND (3) + 2; - lockvar *= 3; + pzfd->noisify = iRAND (goomdata, 3) + 2; + goomdata->lockvar *= 3; } - if (zfd.mode == AMULETTE_MODE) { - zfd.vPlaneEffect = 0; - zfd.hPlaneEffect = 0; - zfd.noisify = 0; + if (pzfd->mode == AMULETTE_MODE) { + pzfd->vPlaneEffect = 0; + pzfd->hPlaneEffect = 0; + pzfd->noisify = 0; } - if ((zfd.middleX == 1) || (zfd.middleX == resolx - 1)) { - zfd.vPlaneEffect = 0; - zfd.hPlaneEffect = iRAND (2) ? 0 : zfd.hPlaneEffect; + if ((pzfd->middleX == 1) || (pzfd->middleX == resolx - 1)) { + pzfd->vPlaneEffect = 0; + pzfd->hPlaneEffect = iRAND (goomdata, 2) ? 0 : pzfd->hPlaneEffect; } - if (newvit < zfd.vitesse) { /* on accelere */ - pzfd = &zfd; + if (newvit < pzfd->vitesse) { /* on accelere */ + zfd_update = 1; 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; + (pzfd->vitesse < STOP_SPEED - 6) && + (goomdata->cycle % 3 == 0)) || (iRAND (goomdata, 40) == 0)) { + pzfd->vitesse = STOP_SPEED - 1; + pzfd->reverse = !pzfd->reverse; } else { - zfd.vitesse = (newvit + zfd.vitesse * 4) / 5; + pzfd->vitesse = (newvit + pzfd->vitesse * 4) / 5; } - lockvar += 50; + goomdata->lockvar += 50; } } } /* mode mega-lent */ - if (iRAND (1000) == 0) { + if (iRAND (goomdata, 1000) == 0) { /* printf ("coup du sort...\n") ; */ - pzfd = &zfd; - zfd.vitesse = STOP_SPEED - 1; - zfd.pertedec = 8; - zfd.sqrtperte = 16; - goomvar = 1; - lockvar += 70; + 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 ((speedvar < 1) && (zfd.vitesse < STOP_SPEED - 4) && (cycle % 16 == 0)) { + if ((goomdata->speedvar < 1) && (pzfd->vitesse < STOP_SPEED - 4) + && (goomdata->cycle % 16 == 0)) { /* printf ("++slow part... %i\n", zfd.vitesse) ; */ - pzfd = &zfd; - zfd.vitesse += 3; - zfd.pertedec = 8; - zfd.sqrtperte = 16; - goomvar = 0; + 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 ((cycle % 73 == 0) && (zfd.vitesse < STOP_SPEED - 5)) { + if ((goomdata->cycle % 73 == 0) && (pzfd->vitesse < STOP_SPEED - 5)) { /* printf ("slow down...\n") ; */ - pzfd = &zfd; - zfd.vitesse++; + zfd_update = 1; + pzfd->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); + if ((goomdata->cycle % 101 == 0) && (pzfd->pertedec == 7)) { + zfd_update = 1; + pzfd->pertedec = 8; + pzfd->sqrtperte = 16; } -#endif /* Zoom here ! */ - zoomFilterFastRGB (p1, p2, pzfd, resolx, resoly); + zoomFilterFastRGB (goomdata, pzfd, zfd_update); /* si on est dans un goom : afficher les lignes... */ - if (agoom > 15) + if (goomdata->agoom > 15) goom_lines - (data, ((zfd.middleX == resolx / 2) && (zfd.middleY == resoly / 2) - && (zfd.mode != WATER_MODE)) - ? (lineMode / 10) : 0, p2, agoom - 15); + (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 = p2; - tmp = p1; - p1 = p2; - p2 = tmp; + return_val = goomdata->p2; + tmp = goomdata->p1; + goomdata->p1 = goomdata->p2; + goomdata->p2 = tmp; /* affichage et swappage des buffers.. */ - cycle++; + goomdata->cycle++; /* tous les 100 cycles : vérifier si le taux de goom est correct */ /* et le modifier sinon.. */ - if (!(cycle % 100)) { - if (totalgoom > 15) { + if (!(goomdata->cycle % 100)) { + if (goomdata->totalgoom > 15) { /* printf ("less gooms\n") ; */ - goomlimit++; + goomdata->goomlimit++; } else { - if ((totalgoom == 0) && (goomlimit > 1)) - goomlimit--; + if ((goomdata->totalgoom == 0) && (goomdata->goomlimit > 1)) + goomdata->goomlimit--; } - totalgoom = 0; + goomdata->totalgoom = 0; } return return_val; } void -goom_close () +goom_close (GoomData * goomdata) { - if (pixel != NULL) - free (pixel); - if (back != NULL) - free (back); - pixel = back = NULL; - RAND_CLOSE (); + if (goomdata->pixel != NULL) + free (goomdata->pixel); + if (goomdata->back != NULL) + free (goomdata->back); + goomdata->pixel = goomdata->back = NULL; + RAND_CLOSE (goomdata); } diff --git a/gst/goom/goom_core.h b/gst/goom/goom_core.h index 15f942d2..1fbc0ee8 100644 --- a/gst/goom/goom_core.h +++ b/gst/goom/goom_core.h @@ -3,11 +3,41 @@ #include -void goom_init (guint32 resx, guint32 resy); -void goom_set_resolution (guint32 resx, guint32 resy); +typedef struct ZoomFilterData ZoomFilterData; -guint32 * goom_update (gint16 data [2][512]); +typedef struct +{ +/**-----------------------------------------------------** + ** SHARED DATA ** + **-----------------------------------------------------**/ + guint32 *pixel; + guint32 *back; + guint32 *p1, *p2; + guint32 cycle; -void goom_close (); + guint32 resolx, resoly, buffsize; + + int lockvar; /* pour empecher de nouveaux changements */ + int goomvar; /* boucle des gooms */ + int totalgoom; /* nombre de gooms par seconds */ + int agoom; /* un goom a eu lieu.. */ + int loopvar; /* mouvement des points */ + int speedvar; /* vitesse des particules */ + int lineMode; /* l'effet lineaire a dessiner */ + char goomlimit; /* sensibilité du goom */ + + ZoomFilterData *zfd; + + /* Random table */ + gint *rand_tab; + guint rand_pos; +} GoomData; + +void goom_init (GoomData *goomdata, guint32 resx, guint32 resy); +void goom_set_resolution (GoomData *goomdata, guint32 resx, guint32 resy); + +guint32 *goom_update (GoomData *goomdata, gint16 data [2][512]); + +void goom_close (GoomData *goomdata); #endif diff --git a/gst/goom/goom_tools.h b/gst/goom/goom_tools.h index 91f310c2..6178dbaf 100644 --- a/gst/goom/goom_tools.h +++ b/gst/goom/goom_tools.h @@ -3,27 +3,22 @@ #define NB_RAND 0x10000 -/* in graphic.c */ -extern int * rand_tab ; -extern unsigned short rand_pos ; +#define RAND_INIT(gd,i) \ + srand (i); \ + if (gd->rand_tab == NULL) \ + gd->rand_tab = g_malloc (NB_RAND * sizeof(gint)) ;\ + gd->rand_pos = 0; \ + while (gd->rand_pos < NB_RAND) \ + gd->rand_tab [gd->rand_pos++] = rand (); -#define RAND_INIT(i) \ - srand (i) ;\ - if (!rand_tab)\ - rand_tab = (int *) malloc (NB_RAND * sizeof(int)) ;\ - rand_pos = 1 ;\ - while (rand_pos != 0)\ - rand_tab [rand_pos++] = rand () ; - -#define RAND()\ - (rand_tab[rand_pos = rand_pos + 1]) - -#define RAND_CLOSE()\ - free (rand_tab);\ - rand_tab = 0; +#define RAND(gd) \ + (gd->rand_tab[gd->rand_pos = ((gd->rand_pos + 1) % NB_RAND)]) +#define RAND_CLOSE(gd) \ + g_free (gd->rand_tab); \ + gd->rand_tab = NULL; /*#define iRAND(i) ((guint32)((float)i * RAND()/RAND_MAX)) */ -#define iRAND(i) (RAND()%i) +#define iRAND(gd,i) (RAND(gd) % i) #endif diff --git a/gst/goom/graphic.c b/gst/goom/graphic.c index 33fff165..c20f987d 100644 --- a/gst/goom/graphic.c +++ b/gst/goom/graphic.c @@ -12,10 +12,3 @@ const Color BLUE = { 0, 0, 0xff }; const Color YELLOW = { 0xff, 0xff, 0x33 }; const Color ORANGE = { 0xff, 0xcc, 0x00 }; const Color VIOLET = { 0x55, 0x00, 0xff }; - -unsigned int SIZE; -unsigned int HEIGHT; -unsigned int WIDTH; - -int *rand_tab = 0; -unsigned short int rand_pos = 0; diff --git a/gst/goom/gstgoom.c b/gst/goom/gstgoom.c index fcee47f6..d5bcb77f 100644 --- a/gst/goom/gstgoom.c +++ b/gst/goom/gstgoom.c @@ -182,7 +182,7 @@ gst_goom_init (GstGoom * goom) goom->samples_consumed = 0; goom->disposed = FALSE; - goom_init (goom->width, goom->height); + goom_init (&(goom->goomdata), goom->width, goom->height); } static void @@ -191,7 +191,7 @@ gst_goom_dispose (GObject * object) GstGoom *goom = GST_GOOM (object); if (!goom->disposed) { - goom_close (); + goom_close (&(goom->goomdata)); goom->disposed = TRUE; g_object_unref (goom->adapter); @@ -233,7 +233,7 @@ gst_goom_src_setcaps (GstPad * pad, GstCaps * caps) &goom->fps_d)) return FALSE; - goom_set_resolution (goom->width, goom->height); + goom_set_resolution (&(goom->goomdata), goom->width, goom->height); return TRUE; } @@ -382,7 +382,7 @@ gst_goom_chain (GstPad * pad, GstBuffer * bufin) GST_BUFFER_DURATION (bufout) = frame_duration; GST_BUFFER_SIZE (bufout) = goom->width * goom->height * 4; - out_frame = (guchar *) goom_update (goom->datain); + out_frame = (guchar *) goom_update (&(goom->goomdata), goom->datain); memcpy (GST_BUFFER_DATA (bufout), out_frame, GST_BUFFER_SIZE (bufout)); GST_DEBUG ("Pushing frame with time=%" G_GUINT64_FORMAT ", duration=%" diff --git a/gst/goom/gstgoom.h b/gst/goom/gstgoom.h index ea17c743..8ecdde87 100644 --- a/gst/goom/gstgoom.h +++ b/gst/goom/gstgoom.h @@ -24,6 +24,7 @@ G_BEGIN_DECLS #include #include +#include "goom_core.h" #define GOOM_SAMPLES 512 @@ -60,6 +61,8 @@ struct _GstGoom gint channels; gboolean disposed; + + GoomData goomdata; }; struct _GstGoomClass diff --git a/gst/goom/lines.c b/gst/goom/lines.c index 0ff6ae20..3214e1db 100644 --- a/gst/goom/lines.c +++ b/gst/goom/lines.c @@ -14,8 +14,6 @@ #include "lines.h" #include -extern unsigned int resolx, resoly; - static inline unsigned char lighten (unsigned char value, unsigned char power) { @@ -27,11 +25,13 @@ lighten (unsigned char value, unsigned char power) } void -goom_lines (gint16 data[2][512], unsigned int ID, unsigned int *p, - guint32 power) +goom_lines (GoomData * goomdata, gint16 data[2][512], unsigned int ID, + unsigned int *p, guint32 power) { guint32 color1; guint32 color2; + guint32 resolx = goomdata->resolx; + guint32 resoly = goomdata->resoly; unsigned char *color = 1 + (unsigned char *) &color1; switch (ID) { diff --git a/gst/goom/lines.h b/gst/goom/lines.h index 3582d380..548f339a 100644 --- a/gst/goom/lines.h +++ b/gst/goom/lines.h @@ -9,7 +9,8 @@ #include #include "graphic.h" +#include "goom_core.h" + +void goom_lines(GoomData *goomdata, gint16 data [2][512], unsigned int ID,unsigned int* p, guint32 power); -void goom_lines(gint16 data [2][512], unsigned int ID,unsigned int* p, guint32 power); -void goom_lines_conf(gint16 config [25]); -- cgit