MythTV: goom_core.c Source File

00001 #include <stdlib.h>
00002 #include <stdio.h>
00003 #include <string.h>
00004 
00005 #include "../config.h"
00006 #ifdef HAVE_STDINT_H
00007 #include <stdint.h>
00008 #endif
00009 
00010 #include <inttypes.h>
00011 
00012 #include "goom_core.h"
00013 #include "goom_tools.h"
00014 #include "filters.h"
00015 #include "lines.h"
00016 #include "ifs.h"
00017 #include "tentacle3d.h"
00018 //#include "gfontlib.h"
00019 
00020 //#define VERBOSE
00021 
00022 #ifdef VERBOSE
00023 #include <stdio.h>
00024 #endif
00025 
00026 #define STOP_SPEED 128
00027 
00028 #define TIME_BTW_CHG 300
00029 
00033 static guint32 *pixel;
00034 static guint32 *back;
00035 static guint32 *p1, *p2, *tmp;
00036 static guint32 cycle;
00037 
00038 typedef struct {
00039         int drawIFS;
00040         int drawPoints;
00041         int drawTentacle;
00042 
00043         int drawScope;
00044         int farScope;
00045 
00046         int rangemin;
00047         int rangemax;
00048 } GoomState;
00049 
00050 #define STATES_NB 8
00051 #define STATES_RANGEMAX 510
00052 GoomState states[STATES_NB] = {
00053         {1,0,0,1,4, 000, 100},
00054         {1,0,0,1,1, 101, 140}, // turned on drawScope
00055         {1,0,0,1,2, 141, 200},
00056         {0,1,0,1,2, 201, 260},
00057         {0,1,0,1,0, 261, 330},
00058         {0,1,1,1,4, 331, 400},
00059         {0,0,1,1,5, 401, 450}, // turned on drawScope
00060         {0,0,1,1,1, 451, 510}
00061 };
00062 
00063 GoomState *curGState = states+4;
00064 
00065 guint32 resolx, resoly, buffsize, c_black_height = 0, c_offset = 0, c_resoly = 0;       /* avec prise en compte de ca */
00066 
00067 // effet de ligne..
00068 static GMLine *gmline1 = NULL;
00069 static GMLine *gmline2 = NULL;
00070 
00071 void    choose_a_goom_line (float *param1, float *param2, int *couleur, int *mode, float *amplitude, int far);
00072 
00073 void goom_init (guint32 resx, guint32 resy, int cinemascope) {
00074 #ifdef VERBOSE
00075         printf ("GOOM: init (%d, %d);\n", resx, resy);
00076 #endif
00077         if (cinemascope)
00078                 c_black_height = resy / 5;
00079         else
00080                 c_black_height = 0;
00081 
00082         resolx = resx;
00083         resoly = resy;
00084         buffsize = resx * resy;
00085 
00086         c_offset = c_black_height * resx;
00087         c_resoly = resy - c_black_height * 2;
00088 
00089         pixel = (guint32 *) malloc (buffsize * sizeof (guint32) + 128);
00090         back = (guint32 *) malloc (buffsize * sizeof (guint32) + 128);
00091         //RAND_INIT ();
00092         srand ((uintptr_t) pixel);
00093         if (!rand_tab) rand_tab = (int *) malloc (NB_RAND * sizeof(int)) ;
00094         rand_pos = 1 ;
00095         while (rand_pos != 0) rand_tab [rand_pos++] = rand () ;
00096                 
00097         cycle = 0;
00098 
00099         p1 = (guint32 *) ((1 + ((uintptr_t) (pixel)) / 128) * 128);
00100         p2 = (guint32 *) ((1 + ((uintptr_t) (back)) / 128) * 128);
00101 
00102         init_ifs (resx, c_resoly);
00103         gmline1 = goom_lines_init (resx, c_resoly, GML_HLINE, c_resoly, GML_BLACK, GML_CIRCLE, 0.4f * (float) c_resoly, GML_VERT);
00104         gmline2 = goom_lines_init (resx, c_resoly, GML_HLINE, 0, GML_BLACK, GML_CIRCLE, 0.2f * (float) c_resoly, GML_RED);
00105 
00106 //      gfont_load ();
00107 
00108         tentacle_new ();
00109 }
00110 
00111 
00112 void goom_set_resolution (guint32 resx, guint32 resy, int cinemascope) {
00113         free (pixel);
00114         free (back);
00115 
00116         if (cinemascope)
00117                 c_black_height = resy / 8;
00118         else
00119                 c_black_height = 0;
00120 
00121         c_offset = c_black_height * resx;
00122         c_resoly = resy - c_black_height * 2;
00123 
00124         resolx = resx;
00125         resoly = resy;
00126         buffsize = resx * resy;
00127 
00128         pixel = (guint32 *) malloc (buffsize * sizeof (guint32) + 128);
00129         memset (pixel, 0, buffsize * sizeof (guint32) + 128);
00130         back = (guint32 *) malloc (buffsize * sizeof (guint32) + 128);
00131         memset (back, 0,  buffsize * sizeof (guint32) + 128);
00132         p1 = (guint32 *) ((1 + ((uintptr_t) (pixel)) / 128) * 128);
00133         p2 = (guint32 *) ((1 + ((uintptr_t) (back)) / 128) * 128);
00134 
00135         init_ifs (resx, c_resoly);
00136         goom_lines_set_res (gmline1, resx, c_resoly);
00137         goom_lines_set_res (gmline2, resx, c_resoly);
00138 }
00139 
00140 
00141 guint32 * goom_update (gint16 data[2][512], int forceMode) {
00142         static int lockvar = 0;                         // pour empecher de nouveaux changements
00143         static int goomvar = 0;                         // boucle des gooms
00144         static int totalgoom = 0;                       // nombre de gooms par seconds
00145         static int agoom = 0;                                   // un goom a eu lieu..      
00146         static int abiggoom = 0;                                        // un big goom a eu lieu..      
00147         static int loopvar = 0;                         // mouvement des points
00148         static int speedvar = 0;                        // vitesse des particules
00149 
00150         // duree de la transition entre afficher les lignes ou pas
00151 #define DRAWLINES 80
00152         static int lineMode = DRAWLINES;        // l'effet lineaire a dessiner
00153         static int nombreCDDC = 0;              // nombre de Cycle Depuis Dernier Changement
00154         guint32 *return_val;
00155         guint32 pointWidth;
00156         guint32 pointHeight;
00157         int     incvar;                                                         // volume du son
00158         static int accelvar=0;                                                  // acceleration des particules
00159         int     i;
00160         float   largfactor;                                             // elargissement de l'intervalle d'�volution
00161         static int stop_lines = 0;
00162 
00163         // des points
00164         static int ifs_incr = 1;                        // dessiner l'ifs (0 = non: > = increment)
00165         static int decay_ifs = 0;                       // disparition de l'ifs
00166         static int recay_ifs = 0;                       // d�disparition de l'ifs
00167 
00168 #define SWITCHMULT (29.0f/30.0f)
00169 #define SWITCHINCR 0x7f
00170         static float switchMult = 1.0f;
00171         static int switchIncr = SWITCHINCR;
00172 
00173         static char goomlimit = 2;              // sensibilit� du goom
00174         static ZoomFilterData zfd = {
00175                 127, 8, 16,
00176                 1, 1, 0, NORMAL_MODE,
00177                 0, 0, 0, 0, 0
00178         };
00179 
00180         ZoomFilterData *pzfd;
00181 
00182         /* test if the config has changed, update it if so */
00183         pointWidth = (resolx * 2) / 5;
00184         pointHeight = ((c_resoly) * 2) / 5;
00185 
00186         /* ! etude du signal ... */
00187         incvar = 0;
00188         for (i = 0; i < 512; i++) {
00189                 if (incvar < data[0][i])
00190                         incvar = data[0][i];
00191         }
00192 
00193         i = accelvar;
00194         accelvar = incvar / 1000;
00195 
00196         if (speedvar > 5) {
00197                 accelvar--;
00198                 if (speedvar > 20)
00199                         accelvar--;
00200                 if (speedvar > 40)
00201                         speedvar = 40;
00202         }
00203         accelvar--;
00204 
00205         i = accelvar - i;
00206         if (i<0) i=-i;
00207 
00208         speedvar += (speedvar + i/2);
00209         speedvar /= 2;
00210         if ((speedvar) && (cycle%9==0)) {
00211                 speedvar -= 1;
00212         }
00213         if ((speedvar) && (cycle%5==0)) {
00214                 speedvar = (speedvar*7)/8;
00215         }
00216 
00217         if (speedvar < 0)
00218                 speedvar = 0;
00219         if (speedvar > 50)
00220                 speedvar = 50;
00221 
00222 
00223         /* ! calcul du deplacement des petits points ... */
00224 
00225         largfactor = ((float) speedvar / 40.0f + (float) incvar / 50000.0f) / 1.5f;
00226         if (largfactor > 1.5f)
00227                 largfactor = 1.5f;
00228 
00229         decay_ifs--;
00230         if (decay_ifs > 0)
00231                 ifs_incr += 2;
00232         if (decay_ifs == 0)
00233                 ifs_incr = 0;
00234 
00235 
00236         if (recay_ifs) {
00237                 ifs_incr -= 2;
00238                 recay_ifs--;
00239                 if ((recay_ifs == 0)&&(ifs_incr<=0))
00240                         ifs_incr = 1;
00241         }
00242 
00243         if (ifs_incr > 0)
00244                 ifs_update (p1 + c_offset, p2 + c_offset, resolx, c_resoly, ifs_incr);
00245         
00246         if (curGState->drawPoints) {
00247                 for (i = 1; i * 15 <= speedvar + 15; i++) {
00248                         loopvar += speedvar*2/3 + 1;
00249 
00250                         pointFilter (p1 + c_offset, YELLOW, ((pointWidth - 6.0f) * largfactor + 5.0f), ((pointHeight - 6.0f) * largfactor + 5.0f), i * 152.0f, 128.0f, loopvar + i * 2032);
00251                         pointFilter (p1 + c_offset, ORANGE, ((pointWidth / 2) * largfactor) / i + 10.0f * i, ((pointHeight / 2) * largfactor) / i + 10.0f * i, 96.0f, i * 80.0f, loopvar / i);
00252                         pointFilter (p1 + c_offset, 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);
00253                         pointFilter (p1 + c_offset, BLACK, ((pointHeight / 3) * largfactor + 20.0f), ((pointHeight / 3) * largfactor + 20.0f), 58.0f, i * 66.0f, loopvar / i); 
00254                         pointFilter (p1 + c_offset, WHITE, (pointHeight * largfactor + 10.0f * i) / i, (pointHeight * largfactor + 10.0f * i) / i, 66.0f, 74.0f, loopvar + i * 500); }
00255         }
00256 
00257         // par d�faut pas de changement de zoom
00258         pzfd = NULL;
00259 
00260         /* 
00261          * Test forceMode
00262          */
00263 #ifdef VERBOSE
00264         if (forceMode != 0) {
00265                 printf ("forcemode = %d\n", forceMode);
00266         }
00267 #endif
00268 
00269 
00270         // diminuer de 1 le temps de lockage
00271         // note pour ceux qui n'ont pas suivis : le lockvar permet d'empecher un
00272         // changement d'etat du plugins juste apres un autre changement d'etat. oki 
00273         // 
00274         // ?
00275         if (--lockvar < 0)
00276                 lockvar = 0;
00277 
00278         // temps du goom
00279         if (--agoom < 0)
00280                 agoom = 0;
00281 
00282         // temps du goom
00283         if (--abiggoom < 0)
00284                 abiggoom = 0;
00285 
00286         if ((!abiggoom) && (speedvar > 4) && (goomlimit > 4) &&
00287                         ((accelvar > goomlimit*9/8+7)||(accelvar < -goomlimit*9/8-7))) {
00288                 int size,i;
00289                 static int couleur =
00290                          (0xc0<<(ROUGE*8))
00291                         |(0xc0<<(VERT*8))
00292                         |(0xf0<<(BLEU*8))
00293                         |(0xf0<<(ALPHA*8));
00294                 abiggoom = 100;
00295                 size = resolx*c_resoly;
00296                 for (i=0;i<size;i++)
00297                         (p1+c_offset)[i] = (~(p1+c_offset)[i]) | couleur;
00298         }
00299 
00300         // on verifie qu'il ne se pas un truc interressant avec le son.
00301         if ((accelvar > goomlimit) || (accelvar < -goomlimit) || (forceMode > 0)
00302                         || (nombreCDDC > TIME_BTW_CHG)) {
00303 
00304 //        if (nombreCDDC > 300) {
00305 //        }
00306 
00307                 // UN GOOM !!! YAHOO !
00308                 totalgoom++;
00309                 agoom = 20;                                                                     // mais pdt 20 cycles, il n'y en aura plus.
00310 
00311                 // changement eventuel de mode
00312                 if (iRAND(16) == 0)
00313                 switch (iRAND (32)) {
00314                 case 0:
00315                 case 10:
00316                         zfd.hypercosEffect = iRAND (2);
00317                 case 13:
00318                 case 20:
00319                 case 21:
00320                         zfd.mode = WAVE_MODE;
00321                         zfd.reverse = 0;
00322                         zfd.waveEffect = (iRAND (3) == 0);
00323                         if (iRAND (2))
00324                                 zfd.vitesse = (zfd.vitesse + 127) >> 1;
00325                         break;
00326                 case 1:
00327                 case 11:
00328                         zfd.mode = CRYSTAL_BALL_MODE;
00329                         zfd.waveEffect = 0;
00330                         zfd.hypercosEffect = 0;
00331                         break;
00332                 case 2:
00333                 case 12:
00334                         zfd.mode = AMULETTE_MODE;
00335                         zfd.waveEffect = 0;
00336                         zfd.hypercosEffect = 0;
00337                         break;
00338                 case 3:
00339                         zfd.mode = WATER_MODE;
00340                         zfd.waveEffect = 0;
00341                         zfd.hypercosEffect = 0;
00342                         break;
00343                 case 4:
00344                 case 14:
00345                         zfd.mode = SCRUNCH_MODE;
00346                         zfd.waveEffect = 0;
00347                         zfd.hypercosEffect = 0;
00348                         break;
00349                 case 5:
00350         case 15:
00351                 case 22:
00352                         zfd.mode = HYPERCOS1_MODE;
00353                         zfd.waveEffect = 0;
00354                         zfd.hypercosEffect = (iRAND (3) == 0);
00355                         break;
00356                 case 6:
00357                 case 16:
00358                         zfd.mode = HYPERCOS2_MODE;
00359                         zfd.waveEffect = 0;
00360                         zfd.hypercosEffect = 0;
00361                         break;
00362                 case 7:
00363                 case 17:
00364                         zfd.mode = CRYSTAL_BALL_MODE;
00365                         zfd.waveEffect = (iRAND (4) == 0);
00366                         zfd.hypercosEffect = iRAND (2);
00367                         break;
00368                 case 8:
00369                 case 18:
00370                 case 19:
00371                         zfd.mode = SCRUNCH_MODE;
00372                         zfd.waveEffect = 1;
00373                         zfd.hypercosEffect = 1;
00374                         break;
00375           case 29:
00376                 case 30:
00377                         zfd.mode = YONLY_MODE;
00378                         break;
00379           case 31:
00380                 case 32:
00381                         zfd.mode = SPEEDWAY_MODE;
00382                         break;
00383                 default:
00384                         zfd.mode = NORMAL_MODE;
00385                         zfd.waveEffect = 0;
00386                         zfd.hypercosEffect = 0;
00387                 }
00388         }
00389         
00390         // tout ceci ne sera fait qu'en cas de non-blocage
00391         if (lockvar == 0) {
00392                 // reperage de goom (acceleration forte de l'acceleration du volume)
00393                 // -> coup de boost de la vitesse si besoin..
00394                 if ((accelvar > goomlimit) || (accelvar < -goomlimit)) {
00395                         static int rndn = 0 ,i;
00396                         static int blocker = 0;
00397                         goomvar++;
00398 
00399                         /* SELECTION OF THE GOOM STATE */
00400                         if ((!blocker)&&(iRAND(3))) {
00401                                 rndn = iRAND(STATES_RANGEMAX);
00402                                 blocker = 3;
00403                         }
00404                         else if (blocker) blocker--;
00405 
00406                         for (i=0;i<STATES_NB;i++)
00407                                 if ((rndn >= states[i].rangemin)
00408                                                 && (rndn <= states[i].rangemax))
00409                                         curGState = states+i;
00410 
00411                         if ((curGState->drawIFS) && (ifs_incr<=0)) {
00412                                 recay_ifs = 5;
00413                                 ifs_incr = 11;
00414                         }
00415 
00416                         if ((!curGState->drawIFS) && (ifs_incr>0) && (decay_ifs<=0))
00417                                 decay_ifs = 100;
00418 
00419                         if (!curGState->drawScope)
00420                                 stop_lines = 0xf000 & 5;
00421                         
00422                         if (!curGState->drawScope) {
00423                                 stop_lines = 0;                 
00424                                 lineMode = DRAWLINES;
00425                         }
00426 
00427                         // if (goomvar % 1 == 0)
00428                         {
00429                                 guint32 vtmp;
00430                                 guint32 newvit;
00431 
00432                                 lockvar = 50;
00433                                 newvit = STOP_SPEED + 1 - ((float)4.0f * log10(speedvar+1));
00434                                 // retablir le zoom avant..
00435                                 if ((zfd.reverse) && (!(cycle % 13)) && (rand () % 5 == 0)) {
00436                                         zfd.reverse = 0;
00437                                         zfd.vitesse = STOP_SPEED - 2;
00438                                         lockvar = 75;
00439                                 }
00440                                 if (iRAND (10) == 0) {
00441                                         zfd.reverse = 1;
00442                                         lockvar = 100;
00443                                 }
00444 
00445                                 if (iRAND (10) == 0)
00446                                         zfd.vitesse = STOP_SPEED - 1;
00447                                 if (iRAND (12) == 0)
00448                                         zfd.vitesse = STOP_SPEED + 1;
00449 
00450                                 // changement de milieu..
00451                                 switch (iRAND (25)) {
00452                                 case 0:
00453                                 case 3:
00454                                 case 6:
00455                                         zfd.middleY = c_resoly - 1;
00456                                         zfd.middleX = resolx / 2;
00457                                         break;
00458                                 case 1:
00459                                 case 4:
00460                                         zfd.middleX = resolx - 1;
00461                                         break;
00462                                 case 2:
00463                                 case 5:
00464                                         zfd.middleX = 1;
00465                                         break;
00466                                 default:
00467                                         zfd.middleY = c_resoly / 2;
00468                                         zfd.middleX = resolx / 2;
00469                                 }
00470 
00471                                 if ((zfd.mode == WATER_MODE)
00472                                                 || (zfd.mode == YONLY_MODE)
00473                                                 || (zfd.mode == AMULETTE_MODE)) {
00474                                         zfd.middleX = resolx / 2;
00475                                         zfd.middleY = c_resoly / 2;
00476                                 }
00477 
00478                                 switch (vtmp = (iRAND (15))) {
00479                                 case 0:
00480                                     
00481                                         zfd.vPlaneEffect = iRAND (3) - iRAND (3);
00482                                         zfd.hPlaneEffect = iRAND (3) - iRAND (3);
00483                                         break;
00484                                 case 3:
00485                                         zfd.vPlaneEffect = 0;
00486                                         zfd.hPlaneEffect = iRAND (8) - iRAND (8);
00487                                         break;
00488                                 case 4:
00489                                 case 5:
00490                                 case 6:
00491                                 case 7:
00492                                         zfd.vPlaneEffect = iRAND (5) - iRAND (5);
00493                                         zfd.hPlaneEffect = -zfd.vPlaneEffect;
00494                                         break;
00495                                 case 8:
00496                                         zfd.hPlaneEffect = 5 + iRAND (8);
00497                                         zfd.vPlaneEffect = -zfd.hPlaneEffect;
00498                                         break;
00499                                 case 9:
00500                                         zfd.vPlaneEffect = 5 + iRAND (8);
00501                                         zfd.hPlaneEffect = -zfd.hPlaneEffect;
00502                                         break;
00503                                 case 13:
00504                                         zfd.hPlaneEffect = 0;
00505                                         zfd.vPlaneEffect = iRAND (10) - iRAND (10);
00506                                         break;
00507                                 case 14:
00508                                         zfd.hPlaneEffect = iRAND (10) - iRAND (10);
00509                                         zfd.vPlaneEffect = iRAND (10) - iRAND (10);
00510                                         break;
00511                                 default:
00512                                         if (vtmp < 10) {
00513                                                 zfd.vPlaneEffect = 0;
00514                                                 zfd.hPlaneEffect = 0;
00515                                         }
00516                                 }
00517 
00518                                 if (iRAND (5) != 0)
00519                                         zfd.noisify = 0;
00520                                 else {
00521                                         zfd.noisify = iRAND (2) + 1;
00522                                         lockvar *= 2;
00523                                 }
00524 
00525                                 if (zfd.mode == AMULETTE_MODE) {
00526                                         zfd.vPlaneEffect = 0;
00527                                         zfd.hPlaneEffect = 0;
00528                                         zfd.noisify = 0;
00529                                 }
00530 
00531                                 if ((zfd.middleX == 1) || (zfd.middleX == (int)resolx - 1)) {
00532                                         zfd.vPlaneEffect = 0;
00533                                         zfd.hPlaneEffect = iRAND (2) ? 0 : zfd.hPlaneEffect;
00534                                 }
00535 
00536                                 if (newvit < (guint32)zfd.vitesse)      // on accelere
00537                                 {
00538                                         pzfd = &zfd;
00539                                         if (((newvit < STOP_SPEED - 7) &&
00540                                                          (zfd.vitesse < STOP_SPEED - 6) &&
00541                                                          (cycle % 3 == 0)) || (iRAND (40) == 0)) {
00542                                                 zfd.vitesse = STOP_SPEED - iRAND (2) + iRAND (2);
00543                                                 zfd.reverse = !zfd.reverse;
00544                                         }
00545                                         else {
00546                                                 zfd.vitesse = (newvit + zfd.vitesse * 7) / 8;
00547                                         }
00548                                         lockvar += 50;
00549                                 }
00550                         }
00551 
00552                         if (lockvar > 150) {
00553                                 switchIncr = SWITCHINCR;
00554                                 switchMult = 1.0f;
00555                         }
00556                 }
00557                 // mode mega-lent
00558                 if (iRAND (700) == 0) {
00559                         pzfd = &zfd;
00560                         zfd.vitesse = STOP_SPEED - 1;
00561                         zfd.pertedec = 8;
00562                         zfd.sqrtperte = 16;
00563                         goomvar = 1;
00564                         lockvar += 50;
00565                         switchIncr = SWITCHINCR;
00566                         switchMult = 1.0f;
00567                 }
00568         }
00569 
00570         /*
00571          * gros frein si la musique est calme
00572          */
00573         if ((speedvar < 1) && (zfd.vitesse < STOP_SPEED - 4) && (cycle % 16 == 0)) {
00574                 pzfd = &zfd;
00575                 zfd.vitesse += 3;
00576                 zfd.pertedec = 8;
00577                 zfd.sqrtperte = 16;
00578                 goomvar = 0;
00579         }
00580 
00581         /*
00582          * baisser regulierement la vitesse...
00583          */
00584         if ((cycle % 73 == 0) && (zfd.vitesse < STOP_SPEED - 5)) {
00585                 pzfd = &zfd;
00586                 zfd.vitesse++;
00587         }
00588 
00589         /*
00590          * arreter de decr�menter au bout d'un certain temps
00591          */
00592         if ((cycle % 101 == 0) && (zfd.pertedec == 7)) {
00593                 pzfd = &zfd;
00594                 zfd.pertedec = 8;
00595                 zfd.sqrtperte = 16;
00596         }
00597 
00598         /*
00599          * Permet de forcer un effet.
00600          */
00601         if ((forceMode > 0) && (forceMode <= NB_FX)) {
00602                 pzfd = &zfd;
00603                 pzfd->mode = forceMode - 1;
00604         }
00605 
00606         if (forceMode == -1) {
00607                 pzfd = NULL;
00608         }
00609 
00610         /*
00611          * Changement d'effet de zoom !
00612          */
00613         if (pzfd != NULL) {
00614                 static int exvit = 128;
00615                 int     dif;
00616 
00617                 nombreCDDC = 0;
00618 
00619                 switchIncr = SWITCHINCR;
00620 
00621                 dif = zfd.vitesse - exvit;
00622                 if (dif < 0)
00623                         dif = -dif;
00624 
00625                 if (dif > 2) {
00626                         switchIncr *= (dif + 2) / 2;
00627                 }
00628                 exvit = zfd.vitesse;
00629                 switchMult = 1.0f;
00630 
00631                 if (((accelvar > goomlimit) && (totalgoom < 2)) || (forceMode > 0)) {
00632                         switchIncr = 0;
00633                         switchMult = SWITCHMULT;
00634                 }
00635         }
00636         else {
00637                 if (nombreCDDC > TIME_BTW_CHG) {
00638                         pzfd = &zfd;
00639                         nombreCDDC = 0;
00640                 }
00641                 else
00642                         nombreCDDC++;
00643         }
00644 
00645 #ifdef VERBOSE
00646         if (pzfd) {
00647                 printf ("GOOM: pzfd->mode = %d\n", pzfd->mode);
00648         }
00649 #endif
00650 
00651         // Zoom here !
00652         zoomFilterFastRGB (p1 + c_offset, p2 + c_offset, pzfd, resolx, c_resoly, switchIncr, switchMult);
00653 
00654         /*
00655          * Affichage tentacule
00656          */
00657 
00658         if (goomlimit!=0)
00659         tentacle_update((gint32*)(p2 + c_offset), (gint32*)(p1 + c_offset), resolx, c_resoly, data, (float)accelvar/goomlimit, curGState->drawTentacle);
00660         else
00661         tentacle_update((gint32*)(p2 + c_offset), (gint32*)(p1 + c_offset), resolx, c_resoly, data,0.0f, curGState->drawTentacle);
00662 
00663 /*
00664         {
00665                 static char title[1024];
00666                 static int displayTitle = 0;
00667                 char    text[255];
00668 
00669                 if (fps > 0) {
00670                         int i;
00671                         if (speedvar>0) {
00672                                 for (i=0;i<speedvar;i++)
00673                                         text[i]='*';
00674                                 text[i]=0;
00675                                 goom_draw_text (p1 + c_offset,resolx,c_resoly, 10, 50, text, 1.0f, 0);
00676                         }
00677                         if (accelvar>0) {
00678                                 for (i=0;i<accelvar;i++) {
00679                                         if (i==goomlimit)
00680                                                 text[i]='o';
00681                                         else
00682                                                 text[i]='*';
00683                                 }
00684                                 text[i]=0;
00685                                 goom_draw_text (p1 + c_offset,resolx,c_resoly, 10, 62, text, 1.0f, 0);
00686                         }
00687                         if (agoom==20)
00688                                 goom_draw_text (p1 + c_offset,resolx,c_resoly,10, 80, "GOOM",1.0f, 0);
00689                         else if (agoom)
00690                                 goom_draw_text (p1 + c_offset,resolx,c_resoly,10, 80, "goom",1.0f, 0);
00691                         if (abiggoom==200)
00692                                 goom_draw_text (p1 + c_offset,resolx,c_resoly,10, 100, "BGOOM",1.0f, 0);
00693                         else if (abiggoom)
00694                                 goom_draw_text (p1 + c_offset,resolx,c_resoly,10, 100, "bgoom",1.0f, 0);
00695                 }
00696 
00697                 update_message (message);
00698 
00699                 if (fps > 0) {
00700                         sprintf (text, "%2.f fps", fps);
00701                         goom_draw_text (p1 + c_offset,resolx,c_resoly, 10, 24, text, 1, 0);
00702                 }
00703 
00704                 if (songTitle != NULL) {
00705                         sprintf (title, songTitle);     // la flemme d'inclure string.h :)
00706                         displayTitle = 200;
00707                 }
00708 
00709                 if (displayTitle) {
00710                         goom_draw_text (p1 + c_offset,resolx,c_resoly, resolx / 2, c_resoly / 2 + 7, title, ((float) (190 - displayTitle) / 10.0f), 1);
00711                         displayTitle--;
00712                         if (displayTitle < 4)
00713                                 goom_draw_text (p2 + c_offset,resolx,c_resoly, resolx / 2, c_resoly / 2 + 7, title, ((float) (190 - displayTitle) / 10.0f), 1);
00714                 }
00715         }
00716 */
00717 
00718         /*
00719          * arret demande
00720          */
00721         if ((stop_lines & 0xf000)||(!curGState->drawScope)) {
00722                 float   param1, param2, amplitude;
00723                 int     couleur;
00724                 int     mode;
00725                 
00726                 choose_a_goom_line (&param1, &param2, &couleur, &mode, &amplitude,1);
00727                 couleur = GML_BLACK;
00728                 
00729                 goom_lines_switch_to (gmline1, mode, param1, amplitude, couleur);
00730                 goom_lines_switch_to (gmline2, mode, param2, amplitude, couleur);
00731                 stop_lines &= 0x0fff;
00732         }
00733         
00734         /*
00735          * arret aleatore.. changement de mode de ligne..
00736          */
00737         if (lineMode != DRAWLINES) {
00738                 lineMode--;
00739                 if (lineMode == -1)
00740                         lineMode = 0;
00741         }
00742         else
00743                 if ((cycle%80==0)&&(iRAND(5)==0)&&lineMode)
00744                         lineMode--;
00745 
00746         if ((cycle % 120 == 0)
00747                         && (iRAND (4) == 0)
00748                         && (curGState->drawScope)) {
00749                 if (lineMode == 0)
00750                         lineMode = DRAWLINES;
00751                 else if (lineMode == DRAWLINES) {
00752                         float   param1, param2, amplitude;
00753                         int     couleur1,couleur2;
00754                         int     mode;
00755 
00756                         lineMode--;
00757                         choose_a_goom_line (&param1, &param2, &couleur1, &mode, &amplitude,stop_lines);
00758 
00759                         couleur2 = 5-couleur1;
00760                         if (stop_lines) {
00761                                 stop_lines--;
00762                                 if (iRAND(2))
00763                                         couleur2=couleur1 = GML_BLACK;
00764                         }
00765 
00766                         goom_lines_switch_to (gmline1, mode, param1, amplitude, couleur1);
00767                         goom_lines_switch_to (gmline2, mode, param2, amplitude, couleur2);
00768                 }
00769         }
00770 
00771         /*
00772          * si on est dans un goom : afficher les lignes...
00773          */
00774         if ((lineMode != 0) || (agoom > 15)) {
00775                 gmline2->power = gmline1->power;
00776 
00777                 goom_lines_draw (gmline1, data[0], p2 + c_offset);
00778                 goom_lines_draw (gmline2, data[1], p2 + c_offset);
00779 
00780                 if (((cycle % 121) == 9) && (iRAND (3) == 1)
00781                                 && ((lineMode == 0) || (lineMode == DRAWLINES))) {
00782                         float   param1, param2, amplitude;
00783                         int     couleur1,couleur2;
00784                         int     mode;
00785 
00786                         choose_a_goom_line (&param1, &param2, &couleur1, &mode, &amplitude, stop_lines);
00787                         couleur2 = 5-couleur1;
00788                         
00789                         if (stop_lines) {
00790                                 stop_lines--;
00791                                 if (iRAND(2))
00792                                         couleur2=couleur1 = GML_BLACK;
00793                         }
00794                         goom_lines_switch_to (gmline1, mode, param1, amplitude, couleur1);
00795                         goom_lines_switch_to (gmline2, mode, param2, amplitude, couleur2);
00796                 }
00797         }
00798 
00799         return_val = p1;
00800         tmp = p1;
00801         p1 = p2;
00802         p2 = tmp;
00803 
00804         // affichage et swappage des buffers..
00805         cycle++;
00806 
00807         // toute les 2 secondes : v�rifier si le taux de goom est correct
00808         // et le modifier sinon..
00809         if (!(cycle % 64)) {
00810                 if (speedvar<1)
00811                         goomlimit /= 2;
00812                 if (totalgoom > 4) {
00813                         goomlimit++;
00814                 }
00815                 if (totalgoom > 7) {
00816                         goomlimit*=4/3;
00817                         goomlimit+=2;
00818                 }
00819                 if ((totalgoom == 0) && (goomlimit > 1))
00820                         goomlimit--;
00821                 if ((totalgoom == 1) && (goomlimit > 1))
00822                         goomlimit--;
00823                 totalgoom = 0;
00824         }
00825         return return_val;
00826 }
00827 
00828 void goom_close () {
00829         if (pixel != NULL)
00830                 free (pixel);
00831         if (back != NULL)
00832                 free (back);
00833         pixel = back = NULL;
00834         RAND_CLOSE ();
00835         release_ifs ();
00836         goom_lines_free (&gmline1);
00837         goom_lines_free (&gmline2);
00838         tentacle_free();
00839 }
00840 
00841 
00842 void choose_a_goom_line (float *param1, float *param2, int *couleur, int *mode, float *amplitude, int far) {
00843         *mode = iRAND (3);
00844         *amplitude = 1.0f;
00845         switch (*mode) {
00846         case GML_CIRCLE:
00847                 if (far) {
00848                         *param1 = *param2 = 0.47f;
00849                         *amplitude = 0.8f;
00850                         break;
00851                 }
00852                 if (iRAND (3) == 0) {
00853                         *param1 = *param2 = 0;
00854                         *amplitude = 3.0f;
00855                 }
00856                 else if (iRAND (2)) {
00857                         *param1 = 0.40f * c_resoly;
00858                         *param2 = 0.22f * c_resoly;
00859                 }
00860                 else {
00861                         *param1 = *param2 = c_resoly * 0.35;
00862                 }
00863                 break;
00864         case GML_HLINE:
00865                 if (iRAND (4) || far) {
00866                         *param1 = c_resoly / 7;
00867                         *param2 = 6.0f * c_resoly / 7.0f;
00868                 }
00869                 else {
00870                         *param1 = *param2 = c_resoly / 2.0f;
00871                         *amplitude = 2.0f;
00872                 }
00873                 break;
00874         case GML_VLINE:
00875                 if (iRAND (3) || far) {
00876                         *param1 = resolx / 7.0f;
00877                         *param2 = 6.0f * resolx / 7.0f;
00878                 }
00879                 else {
00880                         *param1 = *param2 = resolx / 2.0f;
00881                         *amplitude = 1.5f;
00882                 }
00883                 break;
00884         }
00885 
00886         *couleur = iRAND (6);
00887 }
00888 
00889 /*
00890 void goom_set_font (int ***chars, int *width, int *height) {
00891     if (chars == NULL)
00892         return ;
00893 }
00894 */
00895 
00896 /*
00897 void update_message (char *message) {
00898 
00899         static int nbl;
00900         static char msg2 [0x800];
00901         static int affiche = 0;
00902         static int longueur;
00903         int fin = 0;
00904 
00905         if (message) {
00906                 int i=1,j=0;
00907                 sprintf (msg2,message);
00908                 for (j=0;msg2[j];j++)
00909                         if (msg2[j]=='\n')
00910                                 i++;
00911                 nbl = i;
00912                 affiche = resoly + nbl * 25 + 105;
00913                 longueur = strlen (msg2);
00914         }
00915         if (affiche) {
00916                 int i = 0;
00917                 char *msg=malloc(longueur+1);
00918                 char *ptr = msg;
00919                 int pos;
00920                 float ecart;
00921                 message = msg;
00922                 sprintf (msg,msg2);
00923                 
00924                 while (!fin) {
00925                         while (1) {
00926                                 if (*ptr == 0) {
00927                                         fin = 1;
00928                                         break;
00929                                 }
00930                                 if (*ptr == '\n') {
00931                                         *ptr = 0;
00932                                         break;
00933                                 }
00934                                 ++ptr;
00935                         }
00936                         pos = affiche - (nbl-i)*25;
00937                         pos += 6.0*(cos((double)pos/20.0));
00938                         pos -= 80;
00939                         ecart = (1.0+2.0*sin((double)pos/20.0));
00940                         if ((fin) && (2 * pos < (int)resoly))
00941                                 pos = (int)resoly / 2;
00942                         pos += 7;
00943 
00944                         goom_draw_text(p1 + c_offset,resolx,c_resoly, resolx/2, pos, message, ecart, 1);
00945                         message = ++ptr;
00946                         i++;
00947                 }
00948                 affiche --;
00949                 free (msg);
00950         }
00951 }
00952 */