Partage
  • Partager sur Facebook
  • Partager sur Twitter

TP Visualisation spectracle du son

Programme n'affiche rien du tout

coyotte49
    8 août 2006 à 20:44:39

    Salut !
    Donc, j'essaye de faire le dernier TP qui combine FMOD & SDL, mais ma création ne semble pas répondre à mes attentes.


    #include <stdlib.h>
    #include <stdio.h>
    #include <SDL/SDL.h>
    #include <FMOD/fmod.h>

    int main(int argc, char *argv[])
    {
        /* SDL */
       
        SDL_Init (SDL_INIT_VIDEO);
        SDL_Surface* ecran, *ligne[512];
        SDL_Rect pLigne[512];
        ecran = SDL_SetVideoMode (512,400,32,SDL_HWSURFACE);
        SDL_FillRect (ecran, NULL, SDL_MapRGB (ecran -> format,0,0,0));
        SDL_Event event;
       
        SDL_ShowCursor (SDL_DISABLE);
        SDL_WM_SetCaption ("Test", NULL);
       
        /* FMOD */
       
        FSOUND_Init (44100, 32,0);
        FSOUND_DSP_SetActive(FSOUND_DSP_GetFFTUnit(), 1);
        FSOUND_STREAM* zik = NULL;
        zik = FSOUND_Stream_Open ("zik.mp3", 0,0,0);
        FSOUND_Stream_Play (FSOUND_FREE, zik);

        /* VARIABLES */
       
        int continuer = 1, actuel = 0, precedant = 0, i = 0;
        float* spectre = NULL, hauteur = 0;
     
        /* BOUCLES */
       
        while (continuer)
       {
           SDL_PollEvent (&event);
           switch (event.type)
           {
                  case SDL_QUIT :
                       continuer = 0;
                       break;
           }
           
           actuel = SDL_GetTicks();
           
           if (actuel - precedant > 25)
           {
             SDL_FillRect (ecran, NULL, SDL_MapRGB (ecran -> format,0,0,0));         
             spectre = FSOUND_DSP_GetSpectrum();
             
             for (i = 0; i < 512; i++)
             {
               pLigne[i].x = i;
               /* Chaque ligne doit être 1 pixel plus loin que la précédante
                  La variable i prend justement une valeur + 1 */
               pLigne[i].y = 400;  // Les lignes commencent en bas de l'écran
               hauteur = spectre[i] * 400;
               /* Puisque que le spectre est compris entre 0 et 1, il faut le mutliplier
                 par la hauteur de l'écran */
               ligne[i] = SDL_CreateRGBSurface (SDL_HWSURFACE, 1, hauteur, 32,0,0,0,0);
               SDL_FillRect (ligne[i], NULL, SDL_MapRGB (ligne[i] -> format,255,255,255));
               
               SDL_BlitSurface (ligne[i], NULL, ecran, &pLigne[i]);
               SDL_FreeSurface (ligne[i]); // Une fois blittée, on peut libérer ...
             }
          precedant = actuel;
          SDL_Flip(ecran);
         }
           
        }
       
      SDL_Quit();
      FSOUND_Stream_Close (zik);
      FSOUND_DSP_SetActive(FSOUND_DSP_GetFFTUnit(), 0);
      FSOUND_Close();
     
        return 0;
    }


    La musique est bien jouée, mais l'écran reste désespérement noir. Il devrait afficher des lignes (dont la couleur n'est pas rouge au vert, j'essaye d'abord sans les couleurs).
    Je suis certain que le programme va bien dans la boucle.


    Merci de m'aider.
    • Partager sur Facebook
    • Partager sur Twitter
    Jano Lapin
      9 août 2006 à 2:20:41

      Change la ligne
      pLigne[i].y = 400;
      en
      pLigne[i].y = 0;
      et ça ira mieux.
      • Partager sur Facebook
      • Partager sur Twitter
      coyotte49
        9 août 2006 à 13:20:20

        Merci beaucoup ^^:)
        • Partager sur Facebook
        • Partager sur Twitter
        davids42
          9 août 2006 à 13:28:59

          Moi j'aurai plutot dis :
          pLigne[i].y = 400-hauteur;


          pour que tu voit les lignecommencer en bas de l'ecran et non en haut
          • Partager sur Facebook
          • Partager sur Twitter
          coyotte49
            9 août 2006 à 14:22:10

            Oui, ca j'ai trouvé juste après. Par contre, pour le dégradé, je coince aussi (décidement, c'est pas mon meilleur TP...). La fenêtre se ferme brutalement :

            #include <stdlib.h>
            #include <stdio.h>
            #include <SDL/SDL.h>
            #include <FMOD/fmod.h>

            void setPixel(SDL_Surface *surface, int x, int y, Uint32 pixel);

            int main(int argc, char *argv[])
            {
                /* SDL */
               
                SDL_Init (SDL_INIT_VIDEO);
                SDL_Surface* ecran, *ligne[512];
                SDL_Rect pLigne[512];
                ecran = SDL_SetVideoMode (512,400,32,SDL_HWSURFACE);
                SDL_FillRect (ecran, NULL, SDL_MapRGB (ecran -> format,0,0,0));
                SDL_Event event;
               
                SDL_ShowCursor (SDL_DISABLE);
                SDL_WM_SetCaption ("Test", NULL);
               
                /* FMOD */
               
                FSOUND_Init (44100, 32,0);
                FSOUND_DSP_SetActive(FSOUND_DSP_GetFFTUnit(), 1);
                FSOUND_STREAM* zik = NULL;
                zik = FSOUND_Stream_Open ("zik.mp3", 0,0,0);
                FSOUND_Stream_Play (FSOUND_FREE, zik);

                /* VARIABLES */
               
                int continuer = 1, actuel = 0, precedant = 0, i = 0, a = 0;
                float* spectre = NULL, hauteur = 0;
             
                /* BOUCLES */
               
                while (continuer)
               {
                   SDL_PollEvent (&event);
                   switch (event.type)
                   {
                          case SDL_QUIT :
                               continuer = 0;
                               break;
                   }
                   
                   actuel = SDL_GetTicks();
                   
                   if (actuel - precedant > 25)
                   {
                     SDL_FillRect (ecran, NULL, SDL_MapRGB (ecran -> format,0,0,0));         
                     spectre = FSOUND_DSP_GetSpectrum();
                     
                     for (i = 0; i < 512; i++)
                     {
                       SDL_LockSurface(ligne[i]); 
                       pLigne[i].x = i;
                       
                       hauteur = spectre[i] * 400 * 4;
                       if (hauteur > 400)
                         hauteur = 400;
                         
                       pLigne[i].y = 400 - hauteur; 
                       
                       ligne[i] = SDL_CreateRGBSurface (SDL_HWSURFACE, 1, hauteur, 32,0,0,0,0);
                       
                       for (a = 0; a < hauteur; a++)
                           setPixel(ligne[i], pLigne[i].x, pLigne[i].y - a, SDL_MapRGB(ligne[i]->format, 255 - a, a, 0)); // ERREUR ICI
                       
              /* On envoie l'abcisse, qui ne change jamais pour la même ligne.
                 On change l'ordonnée d'un pixel (= variable a) à chaque tour de
                 boucle, pour modifier la couleur de chaque pixel de la ligne.
                 Le rouge diminue, puisque la variable a augmente, tandis que l'intisité de vert augmente */
                       
                       SDL_BlitSurface (ligne[i], NULL, ecran, &pLigne[i]);
                       SDL_FreeSurface (ligne[i]);
                       SDL_UnlockSurface(ligne[i]);
                     }
                  precedant = actuel;
                  SDL_Flip(ecran);
                 }
                   
                }
               
              SDL_Quit();
              FSOUND_Stream_Close (zik);
              FSOUND_DSP_SetActive(FSOUND_DSP_GetFFTUnit(), 0);
              FSOUND_Close();
             
                return 0;
            }

            void setPixel(SDL_Surface *surface, int x, int y, Uint32 pixel)
            {
                int bpp = surface->format->BytesPerPixel;

                Uint8 *p = (Uint8 *)surface->pixels + y * surface->pitch + x * bpp;

                switch(bpp) {
                case 1:
                    *p = pixel;
                    break;

                case 2:
                    *(Uint16 *)p = pixel;
                    break;

                case 3:
                    if(SDL_BYTEORDER == SDL_BIG_ENDIAN) {
                        p[0] = (pixel >> 16) & 0xff;
                        p[1] = (pixel >> 8) & 0xff;
                        p[2] = pixel & 0xff;
                    } else {
                        p[0] = pixel & 0xff;
                        p[1] = (pixel >> 8) & 0xff;
                        p[2] = (pixel >> 16) & 0xff;
                    }
                    break;

                case 4:
                    *(Uint32 *)p = pixel;
                    break;
                }
            }
            • Partager sur Facebook
            • Partager sur Twitter
            Jano Lapin
              10 août 2006 à 2:23:25

              Tu as bien repéré la ligne où il y a une erreur. Regarde les valeurs que les arguments de SDL_MapRGB peuvent prendre et tu auras ta réponse.
              • Partager sur Facebook
              • Partager sur Twitter
              coyotte49
                10 août 2006 à 11:07:08

                Encore une fois, merci :p
                Effectiment, la variable a qui monte au dessus des 255, ca peut faire un beau plantage. :-° J'ai corrigé avec une autre variable et une division (Heu... En espérent que ca soit correct...).

                Mais visiblement, ca n'était pas la seul erreur. Mon programme continue à se fermer brutalement à son lancement (pas de Warnings).

                Note : Si je remplace, dans SDL_MapRGB, toutes les couleurs par 255,255,255, j'ai toujours ce plantage (avec le prog de l'autre post et avec ce prog).


                #include <stdlib.h>
                #include <stdio.h>
                #include <SDL/SDL.h>
                #include <FMOD/fmod.h>

                void setPixel(SDL_Surface *surface, int x, int y, Uint32 pixel);

                int main(int argc, char *argv[])
                {
                    /* SDL */
                   
                    SDL_Init (SDL_INIT_VIDEO);
                    SDL_Surface* ecran, *ligne[512];
                    SDL_Rect pLigne[512];
                    ecran = SDL_SetVideoMode (512,400,32,SDL_HWSURFACE);
                    SDL_FillRect (ecran, NULL, SDL_MapRGB (ecran -> format,0,0,0));
                    SDL_Event event;
                   
                    SDL_ShowCursor (SDL_DISABLE);
                    SDL_WM_SetCaption ("Test", NULL);
                   
                    /* FMOD */
                   
                    FSOUND_Init (44100, 32,0);
                    FSOUND_DSP_SetActive(FSOUND_DSP_GetFFTUnit(), 1);
                    FSOUND_STREAM* zik = NULL;
                    zik = FSOUND_Stream_Open ("zik.mp3", 0,0,0);
                    FSOUND_Stream_Play (FSOUND_FREE, zik);

                    /* VARIABLES */
                   
                    int continuer = 1, actuel = 0, precedant = 0, i = 0, a = 0, couleur = 0;
                    float* spectre = NULL, hauteur = 0;
                 
                    /* BOUCLES */
                   
                    while (continuer)
                   {
                       SDL_PollEvent (&event);
                       switch (event.type)
                       {
                              case SDL_QUIT :
                                   continuer = 0;
                                   break;
                       }
                       
                       actuel = SDL_GetTicks();
                       
                       if (actuel - precedant > 25)
                       {
                         SDL_FillRect (ecran, NULL, SDL_MapRGB (ecran -> format,0,0,0));         
                         spectre = FSOUND_DSP_GetSpectrum();
                         
                         for (i = 0; i < 512; i++)
                         {
                           SDL_LockSurface(ligne[i]); 
                           pLigne[i].x = i;
                           
                           hauteur = spectre[i] * 400 * 4;
                           if (hauteur > 400)
                             hauteur = 400;
                             
                           pLigne[i].y = 400 - hauteur; 
                           
                           ligne[i] = SDL_CreateRGBSurface (SDL_HWSURFACE, 1, hauteur, 32,0,0,0,0);
                           couleur = 255 / hauteur;
                           for (a = 0; a < hauteur; a++)
                           {
                               setPixel(ligne[i], i, pLigne[i].y - a, SDL_MapRGB(ligne[i]->format, 255 - couleur, couleur, 0));
                               couleur += couleur;
                           }
                           
                           SDL_BlitSurface (ligne[i], NULL, ecran, &pLigne[i]);
                           SDL_FreeSurface (ligne[i]);
                           SDL_UnlockSurface(ligne[i]);
                         }
                      precedant = actuel;
                      SDL_Flip(ecran);
                     }
                       
                    }
                   
                  SDL_Quit();
                  FSOUND_Stream_Close (zik);
                  FSOUND_DSP_SetActive(FSOUND_DSP_GetFFTUnit(), 0);
                  FSOUND_Close();
                 
                    return 0;
                }

                void setPixel(SDL_Surface *surface, int x, int y, Uint32 pixel)
                {
                    int bpp = surface->format->BytesPerPixel;

                    Uint8 *p = (Uint8 *)surface->pixels + y * surface->pitch + x * bpp;

                    switch(bpp) {
                    case 1:
                        *p = pixel;
                        break;

                    case 2:
                        *(Uint16 *)p = pixel;
                        break;

                    case 3:
                        if(SDL_BYTEORDER == SDL_BIG_ENDIAN) {
                            p[0] = (pixel >> 16) & 0xff;
                            p[1] = (pixel >> 8) & 0xff;
                            p[2] = pixel & 0xff;
                        } else {
                            p[0] = pixel & 0xff;
                            p[1] = (pixel >> 8) & 0xff;
                            p[2] = (pixel >> 16) & 0xff;
                        }
                        break;

                    case 4:
                        *(Uint32 *)p = pixel;
                        break;
                    }
                }
                • Partager sur Facebook
                • Partager sur Twitter
                coyotte49
                coyotte49
                  12 août 2006 à 14:54:49

                  Donc, le prog se ferme dès son exécution. V'la la source :

                  #include <stdlib.h>
                  #include <stdio.h>
                  #include <SDL/SDL.h>
                  #include <FMOD/fmod.h>

                  void setPixel(SDL_Surface *surface, int x, int y, Uint32 pixel);

                  int main(int argc, char *argv[])
                  {
                      /* SDL */
                     
                      SDL_Init (SDL_INIT_VIDEO);
                      SDL_Surface* ecran, *ligne[512];
                      SDL_Rect pLigne[512];
                      ecran = SDL_SetVideoMode (512,400,32,SDL_HWSURFACE);
                      SDL_FillRect (ecran, NULL, SDL_MapRGB (ecran -> format,0,0,0));
                      SDL_Event event;
                     
                      SDL_ShowCursor (SDL_DISABLE);
                      SDL_WM_SetCaption ("Test", NULL);
                     
                      /* FMOD */
                     
                      FSOUND_Init (44100, 32,0);
                      FSOUND_DSP_SetActive(FSOUND_DSP_GetFFTUnit(), 1);
                      FSOUND_STREAM* zik = NULL;
                      zik = FSOUND_Stream_Open ("zik.mp3", 0,0,0);
                      FSOUND_Stream_Play (FSOUND_FREE, zik);

                      /* VARIABLES */
                     
                      int continuer = 1, actuel = 0, precedant = 0, i = 0, a = 0, couleur = 0;
                      float* spectre = NULL, hauteur = 0;
                   
                      /* BOUCLES */
                     
                      while (continuer)
                     {
                         SDL_PollEvent (&event);
                         switch (event.type)
                         {
                                case SDL_QUIT :
                                     continuer = 0;
                                     break;
                         }
                         
                         actuel = SDL_GetTicks();
                         
                         if (actuel - precedant > 25)
                         {
                           SDL_FillRect (ecran, NULL, SDL_MapRGB (ecran -> format,0,0,0));         
                           spectre = FSOUND_DSP_GetSpectrum();
                           
                           for (i = 0; i < 512; i++)
                           {
                             SDL_LockSurface(ligne[i]); 
                             pLigne[i].x = i;
                             
                             hauteur = spectre[i] * 400 * 4;
                             if (hauteur > 400)
                               hauteur = 400;
                               
                             pLigne[i].y = 400 - hauteur; 
                             
                             ligne[i] = SDL_CreateRGBSurface (SDL_HWSURFACE, 1, hauteur, 32,0,0,0,0);
                             couleur = 255 / hauteur;
                             /* La couleur doit évidemment varier selon la hauteur :
                                Si ligne grande, il faut venir doucement du vert au rouge
                                et inversément. Donc, plus la hauteur est grande, plus la
                                couleur est faible.
                             */

                             for (a = 0; a < hauteur; a++)
                             {
                                 setPixel(ligne[i], pLigne[i].x, pLigne[i].y + a, SDL_MapRGB(ligne[i]->format, 255 - couleur, couleur, 0));

                            /* pLigne[i].y - a : pour que toute la ligne soit mise en couleur,
                               on monte petit à petit en y. */
                                 couleur += couleur;
                             }
                             
                             SDL_BlitSurface (ligne[i], NULL, ecran, &pLigne[i]);
                             SDL_FreeSurface (ligne[i]);
                             SDL_UnlockSurface(ligne[i]);
                           }
                        precedant = actuel;
                        SDL_Flip(ecran);
                       }
                         
                      }
                     
                    SDL_Quit();
                    FSOUND_Stream_Close (zik);
                    FSOUND_DSP_SetActive(FSOUND_DSP_GetFFTUnit(), 0);
                    FSOUND_Close();
                   
                      return 0;
                  }

                  void setPixel(SDL_Surface *surface, int x, int y, Uint32 pixel)
                  {
                      int bpp = surface->format->BytesPerPixel;

                      Uint8 *p = (Uint8 *)surface->pixels + y * surface->pitch + x * bpp;

                      switch(bpp) {
                      case 1:
                          *p = pixel;
                          break;

                      case 2:
                          *(Uint16 *)p = pixel;
                          break;

                      case 3:
                          if(SDL_BYTEORDER == SDL_BIG_ENDIAN) {
                              p[0] = (pixel >> 16) & 0xff;
                              p[1] = (pixel >> 8) & 0xff;
                              p[2] = pixel & 0xff;
                          } else {
                              p[0] = pixel & 0xff;
                              p[1] = (pixel >> 8) & 0xff;
                              p[2] = (pixel >> 16) & 0xff;
                          }
                          break;

                      case 4:
                          *(Uint32 *)p = pixel;
                          break;
                      }
                  }

                  • Partager sur Facebook
                  • Partager sur Twitter
                  coyotte49
                  coyotte49
                  Abeul
                    14 août 2006 à 21:53:42

                    Salut pourquoi creer une variable SDL_Rect sous forme de tableau a 512 case o_Oo_O tu blit chaque barre une à la fois donc plutôt creer une variable SDL_Rect position et la changer de valeur dans la boucle .

                    +
                    • Partager sur Facebook
                    • Partager sur Twitter
                    coyotte49
                      15 août 2006 à 9:50:26

                      Merci de ta réponse :)
                      Ca ne change bien sûr rien au résultat, mais c'est vrai que c'est plut optimisé comme ca :p


                      /* Le programme se ferme dès son exécution */

                      #include <stdlib.h>
                      #include <stdio.h>
                      #include <SDL/SDL.h>
                      #include <FMOD/fmod.h>

                      void setPixel(SDL_Surface *surface, int x, int y, Uint32 pixel);

                      int main(int argc, char *argv[])
                      {
                          /* SDL */
                         
                          SDL_Init (SDL_INIT_VIDEO);
                          SDL_Surface* ecran, *ligne[512];
                          SDL_Rect pLigne;
                          ecran = SDL_SetVideoMode (512,400,32,SDL_HWSURFACE);
                          SDL_FillRect (ecran, NULL, SDL_MapRGB (ecran -> format,0,0,0));
                          SDL_Event event;
                         
                          SDL_ShowCursor (SDL_DISABLE);
                          SDL_WM_SetCaption ("Test", NULL);
                         
                          /* FMOD */
                         
                          FSOUND_Init (44100, 32,0);
                          FSOUND_DSP_SetActive(FSOUND_DSP_GetFFTUnit(), 1);
                          FSOUND_STREAM* zik = NULL;
                          zik = FSOUND_Stream_Open ("zik.mp3", 0,0,0);
                          FSOUND_Stream_Play (FSOUND_FREE, zik);

                          /* VARIABLES */
                         
                          int continuer = 1, actuel = 0, precedant = 0, i = 0, a = 0, couleur = 0;
                          float* spectre = NULL, hauteur = 0;
                       
                          /* BOUCLES */
                         
                       while (continuer)
                       {
                             SDL_PollEvent (&event);
                           switch (event.type)
                           {
                                    case SDL_QUIT :
                                         continuer = 0;
                                         break;
                           }
                             
                             actuel = SDL_GetTicks();
                             
                          if (actuel - precedant > 25)
                         {
                               SDL_FillRect (ecran, NULL, SDL_MapRGB (ecran -> format,0,0,0));         
                               spectre = FSOUND_DSP_GetSpectrum();
                               
                               for (i = 0; i < 512; i++)
                             {
                                 SDL_LockSurface(ligne[i]); 
                                 pLigne.x = i;
                                 
                                 hauteur = spectre[i] * 400 * 4;
                                 if (hauteur > 400)
                                   hauteur = 400;
                                   
                                 pLigne.y = 400 - hauteur; 
                                 
                                 ligne[i] = SDL_CreateRGBSurface (SDL_HWSURFACE, 1, hauteur, 32,0,0,0,0);
                                 couleur = 255 / hauteur;
                                  for (a = 0; a < hauteur; a++)
                                 {
                                     setPixel(ligne[i], pLigne.x, pLigne.y + a, SDL_MapRGB(ligne[i] ->format, 255 - couleur, couleur, 0));
                                     couleur += couleur;
                                 }
                                 
                                 SDL_BlitSurface (ligne[i], NULL, ecran, &pLigne);
                                 SDL_UnlockSurface(ligne[i]);           
                                 SDL_FreeSurface (ligne[i]);
                            }
                            precedant = actuel;
                            SDL_Flip(ecran);
                           }
                             
                         }
                         
                        SDL_Quit();
                        FSOUND_Stream_Close (zik);
                        FSOUND_DSP_SetActive(FSOUND_DSP_GetFFTUnit(), 0);
                        FSOUND_Close();
                       
                          return 0;
                      }

                      void setPixel(SDL_Surface *surface, int x, int y, Uint32 pixel)
                      {
                          int bpp = surface->format->BytesPerPixel;

                          Uint8 *p = (Uint8 *)surface->pixels + y * surface->pitch + x * bpp;

                          switch(bpp) {
                          case 1:
                              *p = pixel;
                              break;

                          case 2:
                              *(Uint16 *)p = pixel;
                              break;

                          case 3:
                              if(SDL_BYTEORDER == SDL_BIG_ENDIAN) {
                                  p[0] = (pixel >> 16) & 0xff;
                                  p[1] = (pixel >> 8) & 0xff;
                                  p[2] = pixel & 0xff;
                              } else {
                                  p[0] = pixel & 0xff;
                                  p[1] = (pixel >> 8) & 0xff;
                                  p[2] = (pixel >> 16) & 0xff;
                              }
                              break;

                          case 4:
                              *(Uint32 *)p = pixel;
                              break;
                          }
                      }

                      • Partager sur Facebook
                      • Partager sur Twitter
                      Abeul
                        15 août 2006 à 15:26:06

                        Salut bon j'ai regarder un peu ton code j'ai réussi à afficher les barres mais y a un problème dans les couleurs enfin bref tu verra je t'explique ce que j'ai modifier.

                        Bon j'ai modifier la variable SDL_Rect comme je te l'ai dit dans mon dernier post.
                        Et ensuite en fait tu avait faire SDL_LockSurface(ligne[i]) au lieu de SDL_LockSurface(ecran) idem pour SDL_UnLockSurface , deplus tu avait mit:

                        setPixel(ligne[i], pLigne.x, pLigne.y + a, SDL_MapRGB(ligne[i]->format, 255 - couleur, couleur, 0));


                        au lieu de

                        setPixel(ecran, pLigne.x, pLigne.y + a, SDL_MapRGB(ligne[i]->format, 255 - couleur, couleur, 0));


                        Donc voila maintenant à toi de jouer pour les couleurs .
                        ++

                        #include <stdlib.h>
                        #include <stdio.h>
                        #include <SDL/SDL.h>
                        #include <FMOD/fmod.h>

                        void setPixel(SDL_Surface *surface, int x, int y, Uint32 pixel);

                        int main(int argc, char *argv[])
                        {
                            /* SDL */

                            SDL_Init (SDL_INIT_VIDEO);
                            SDL_Surface* ecran, *ligne[512];
                            SDL_Rect pLigne;
                            ecran = SDL_SetVideoMode (512,400,32,SDL_HWSURFACE);
                            SDL_FillRect (ecran, NULL, SDL_MapRGB (ecran -> format,0,0,0));
                            SDL_Event event;

                            SDL_ShowCursor (SDL_ENABLE);
                            SDL_WM_SetCaption ("Test", NULL);

                            /* FMOD */

                            FSOUND_Init (44100, 32,0);
                            FSOUND_DSP_SetActive(FSOUND_DSP_GetFFTUnit(), 1);
                            FSOUND_STREAM* zik = NULL;
                            zik = FSOUND_Stream_Open ("zik.mp3", 0,0,0);
                            FSOUND_Stream_Play (FSOUND_FREE, zik);

                            /* VARIABLES */

                            int continuer = 1, actuel = 0, precedant = 0, i = 0, a = 0, couleur = 0;
                            float* spectre = NULL, hauteur = 0;

                            /* BOUCLES */

                            while (continuer)
                           {
                               SDL_PollEvent (&event);
                               switch (event.type)
                               {
                                      case SDL_QUIT :
                                           continuer = 0;
                                           break;
                               }

                               actuel = SDL_GetTicks();

                               if (actuel - precedant > 25)
                               {
                                 SDL_FillRect (ecran, NULL, SDL_MapRGB (ecran -> format,0,0,0));
                                 spectre = FSOUND_DSP_GetSpectrum();

                                 for (i = 0; i < 512; i++)
                                 {
                                   SDL_LockSurface(ecran);
                                   pLigne.x = i;

                                   hauteur = spectre[i] * 400 * 4;
                                   if (hauteur > 400)
                                     hauteur = 400;

                                   pLigne.y = 400 - hauteur;

                                   ligne[i] = SDL_CreateRGBSurface (SDL_HWSURFACE, 1, hauteur, 32,0,0,0,0);
                                   couleur = 255 / hauteur;
                                   /* La couleur doit évidemment varier selon la hauteur :
                                      Si ligne grande, il faut venir doucement du vert au rouge
                                      et inversément. Donc, plus la hauteur est grande, plus la
                                      couleur est faible.
                                   */

                                   for (a = 0; a < hauteur; a++)
                                   {
                                       setPixel(ecran, pLigne.x, pLigne.y + a, SDL_MapRGB(ligne[i]->format, 255 - couleur, couleur, 0));

                                  /* pLigne[i].y - a : pour que toute la ligne soit mise en couleur,
                                     on monte petit à petit en y. */
                                       couleur += couleur;
                                   }

                                   SDL_BlitSurface (ligne[i], NULL, ecran, &pLigne);
                                   SDL_FreeSurface (ligne[i]);
                                   SDL_UnlockSurface(ecran);
                                 }
                              precedant = actuel;
                              SDL_Flip(ecran);
                             }

                            }

                          SDL_Quit();
                          FSOUND_Stream_Close (zik);
                          FSOUND_DSP_SetActive(FSOUND_DSP_GetFFTUnit(), 0);
                          FSOUND_Close();

                            return 0;
                        }

                        void setPixel(SDL_Surface *surface, int x, int y, Uint32 pixel)
                        {
                            int bpp = surface->format->BytesPerPixel;

                            Uint8 *p = (Uint8 *)surface->pixels + y * surface->pitch + x * bpp;

                            switch(bpp) {
                            case 1:
                                *p = pixel;
                                break;

                            case 2:
                                *(Uint16 *)p = pixel;
                                break;

                            case 3:
                                if(SDL_BYTEORDER == SDL_BIG_ENDIAN) {
                                    p[0] = (pixel >> 16) & 0xff;
                                    p[1] = (pixel >> 8) & 0xff;
                                    p[2] = pixel & 0xff;
                                } else {
                                    p[0] = pixel & 0xff;
                                    p[1] = (pixel >> 8) & 0xff;
                                    p[2] = (pixel >> 16) & 0xff;
                                }
                                break;

                            case 4:
                                *(Uint32 *)p = pixel;
                                break;
                            }
                        }

                        • Partager sur Facebook
                        • Partager sur Twitter
                        coyotte49
                          16 août 2006 à 10:54:26

                          Whaaa, merci :):)
                          Je m'occupe des couleurs de suite.

                          • Partager sur Facebook
                          • Partager sur Twitter

                          TP Visualisation spectracle du son

                          × Après avoir cliqué sur "Répondre" vous serez invité à vous connecter pour que votre message soit publié.
                          × Attention, ce sujet est très ancien. Le déterrer n'est pas forcément approprié. Nous te conseillons de créer un nouveau sujet pour poser ta question.
                          • Editeur ●
                          • Markdown