Discussion :

[sieuzac]

Salut a tous
Je suis en train de développer une interface graphique sous SDL.
Le problème viens de la lenteur de mon code
en 1024*768*16bit il m'affiche 8 image par seconde seulement.
Voici mon code

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
 
#include <SDL/SDL.h>
#include <stdio.h>
 
 
 
/* surface qui sert à l'affichage dans la mémoire vidéo */
SDL_Surface *ecran = NULL;
 
 
//On crée une surface dans la mémoire système
SDL_Surface *Virtuel = NULL;
 
 
 
void dot(int x, int y, char rouge, char gaune, char bleu)
{
  *((Uint16*)(Virtuel->pixels) + x + y * Virtuel->w) = SDL_MapRGB(Virtuel->format, rouge, gaune, bleu);
}
 
void attendreTouche(void)
{
  SDL_Event event;
 
  do
    SDL_WaitEvent(&event);
  while (event.type != SDL_QUIT && event.type != SDL_KEYDOWN);
}
 
int main(int argc, char **argv)
{
  /* SDL_INIT_VIDEO si besoin de seulement la vidéo */
  if (SDL_Init(SDL_INIT_EVERYTHING) == -1)
  {
    printf("Error: %s\n", SDL_GetError());
    return 1;
  }
  ecran = SDL_SetVideoMode(1024, 768, 16, SDL_HWSURFACE | SDL_DOUBLEBUF | SDL_FULLSCREEN | SDL_HWACCEL);
  Virtuel = SDL_CreateRGBSurface(SDL_HWSURFACE, ecran->w, ecran->h, 16, 0, 0, 0, 0);
 
  if (ecran == NULL)
  {
    printf("Error: %s\n", SDL_GetError());
    return 1;
  }
 
 
  if (Virtuel == NULL)
  {
    printf("Error: %s\n", SDL_GetError());
    return 1;
  }
 
    int i;
    int j;
    int k;
    int co1;
    int co2;
    int co3;
    for (j = 0; j < 80; j++)
    {
        co1 = rand() % 255;
        co2 = rand() % 255;
        co3 = rand() % 255;
        for (i = 0; i < 1024; i++)
        { 
          for (k = 0; k < 768; k++) dot(i, k, co1, co2 ,co3);
          {
            dot(i,j,co1,co2,co3);
          }
        }
        SDL_BlitSurface(Virtuel, NULL, ecran, NULL);
        SDL_Flip(ecran);
    }
 
    attendreTouche();
 
}

Pouvez vous me dire se qu'il ne va pas.

@+++

[fearyourself]

Bonjour,

Ton code n'est pas logique, qu'essaies-tu de faire ?

- Si tu veux changer la couleur de fond, utilise SDL_FillRect.
- Pour rendre le tout plus rapide, utilise aussi SDL_DisplayFormat
- Le code de ta boucle est bizarre, surtout le premier appel à ta fonction dot qui utilise les paramètres i,j... Ensuite, on dirait que tu n'as pas vu celui qui se trouve sur la même ligne du for... Es-tu au courant des conséquences de mettre ca là ?
- SDL_HWACCEL n'est pas à être utilisé là...

Jc

[sieuzac]

Dans ce code je fais une mise en situation ou je calcule une image et que je l'affiche. Après s'est un peut le bordel je le reconnais. Je sort apène de la prog VESA il faus que je mi habitue.L'objectif est d'afficher un nombre maximale d'image par seconde.
@++

[Invité]

Dans ce cas, autant commencer tout de suite...

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
 
  int flags = SDL_HWSURFACE | SDL_DOUBLEBUF | SDL_FULLSCREEN;
 
  ecran = SDL_SetVideoMode(1024, 768, 16, flags);
 
  if (ecran == NULL)
  {
    printf("Error: %s\n", SDL_GetError());
    return 1;
  }
 
  // on recupere la taille de l'écran...
  SDL_Rect rect_ecran = {0, 0, 1024, 768};
 
    int co1;
    int co2;
    int co3;
 
	unsigned int color;
 
    for (int j = 0; j < 80; j++)
    {
        co1 = rand() % 255;
        co2 = rand() % 255;
        co3 = rand() % 255;
 
		color = SDL_MapRGB(ecran->format, co1, co2, co3);
 
		SDL_FillRect(ecran, rect_ecran, color);
 
        SDL_Flip(ecran);
    }

ceci sera déja un peu plus rapide... tu as déja du double buffuring d'activé, stocker ta surface en plus des 2 déjà créés par SDL, c'est juste un peu overkill... de plus, ta methode pour mapper les pixels est assez spéciale... un memcpy() aurait été un peu plus adaptée (mais ici, tu as SDL_FillRect() à ta disposition, autant en profiter)

[fearyourself]

(mais ici, tu as SDL_FillRect() à ta disposition, autant en profiter)

Certes, mais le deuxième argument est un pointeur vers un SDL_Rect et si tu passes NULL, il remplit toute la surface.

Autant faire ceci alors :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

		SDL_FillRect(ecran, NULL, color);

[Invité]

Ah oui, c'est vrai, au temps pour moi... deplus, je n'ai pas filé la bonne chose ici (c'est ça de pas complier)

[sieuzac]

merci beaucoup
Maintenant peux t'ont remplacer color par un tableau de donnée

exemple

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
 
#include <SDL/SDL.h>
#include <stdio.h>
#include <time.h>
#include <string.h>
 
 
int main(int argc, char **argv)
{
 
  /* SDL_INIT_VIDEO si besoin de seulement la vidéo */
  if (SDL_Init(SDL_INIT_VIDEO) == -1)
  {
    printf("Error: %s\n", SDL_GetError());
    return 1;
  }
 
 
/* surface qui sert à l'affichage dans la mémoire vidéo */
SDL_Surface *ecran = NULL;
 
  int flags = SDL_HWSURFACE | SDL_DOUBLEBUF | SDL_FULLSCREEN;
 
  ecran = SDL_SetVideoMode(1024, 768, 16, flags);
 
  if (ecran == NULL)
  {
    printf("Error: %s\n", SDL_GetError());
    return 1;
  }
 
  // on recupere la taille de l'écran...
  //SDL_Rect rect_ecran = {0, 0, 1024, 768};
 
    int co1;
    int co2;
    int co3;
    int j = 0;
 
	unsigned int color[786432];
 
    for (j = 0; j < 80; j++)
    {
        co1 = rand() % 255;
        co2 = rand() % 255;
        co3 = rand() % 255;
 
		//color = SDL_MapRGB(ecran->format, co1, co2, co3);
		memeset(color,SDL_MapRGB(ecran->format, co1, co2, co3),12582912);
 
		SDL_FillRect(ecran, NULL, color);
 
        SDL_Flip(ecran);
    }
 
}

Ce code ne fonctionne pas car SDL_FillRect() agit comme memset().
Sur ce code écran a une couleur unique. En réalité chaque point a une couleur différente.

@+

[fearyourself]

merci beaucoup
Maintenant peux t'ont remplacer color par un tableau de donnée

Non, de toute facon, ce que tu essaies de faire va contre toute bibliothèque de rendu.

L'affichage par pixel sera toujours très lent par rapport à afficher par rectangle pour de la 2D et triangle pour la 3D... Il va falloir sortir de cette idée de vouloir gérer chaque pixel de ta fenêtre par rendu...

Jc

[sieuzac]

C'est bon j'ai trouvez la solution a mon problème.
Merci a tous pour vos réponse.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
 
#include <SDL/SDL.h>
#include <stdio.h>
#include <time.h>
 
/* surface qui sert à l'affichage dans la mémoire vidéo */
SDL_Surface *ecran = NULL;
 
 
//On crée une surface dans la mémoire système
SDL_Surface *Virtuel = NULL;
 
 
 
inline void dot(int x, int y, char rouge, char gaune, char bleu)
{
*((Uint16*)(Virtuel->pixels) + x + y * Virtuel->w) = SDL_MapRGB(Virtuel->format, rouge, gaune, bleu);
}
 
void attendreTouche(void)
{
SDL_Event event;
 
do
SDL_WaitEvent(&event);
while (event.type != SDL_QUIT && event.type != SDL_KEYDOWN);
}
 
int main(int argc, char **argv)
{
/* SDL_INIT_VIDEO si besoin de seulement la vidéo */
if (SDL_Init(SDL_INIT_EVERYTHING) == -1)
{
printf("Error: %s\n", SDL_GetError());
return 1;
}
ecran = SDL_SetVideoMode(1024, 768, 16, SDL_HWSURFACE | SDL_DOUBLEBUF | SDL_HWACCEL | SDL_FULLSCREEN);
Virtuel = SDL_CreateRGBSurface(SDL_HWSURFACE, ecran->w, ecran->h, 16, 0, 0, 0, 0);
 
if (ecran == NULL)
{
printf("Error: %s\n", SDL_GetError());
return 1;
}
 
 
if (Virtuel == NULL)
{
printf("Error: %s\n", SDL_GetError());
return 1;
}
 
int i;
int j;
int k;
int co1;
int co2;
int co3;
 
clock_t c0 = clock();
 
for (j = 0; j < 80; j++)
{
    co1 = rand() % 255;
    co2 = rand() % 255;
    co3 = rand() % 255;
 
    for (i = 0; i < 1024; i++)
        for (k = 0; k < 768; k++) 
            dot(i, k, co1, co2 ,co3);
    SDL_BlitSurface(Virtuel, NULL, ecran, NULL);
    SDL_Flip(ecran);
}
clock_t c1 = clock();
for (j = 0; j < 80; j++)
{
    co1 = rand() % 255;
    co2 = rand() % 255;
    co3 = rand() % 255;
 
    Uint16 rgb = SDL_MapRGB(Virtuel->format, co1, co2, co3);
    Uint16* p =(Uint16*)(Virtuel->pixels);
    for (i=0; i<1024*768; i++) 
        *p++ = rgb;
 
    SDL_BlitSurface(Virtuel, NULL, ecran, NULL);
    SDL_Flip(ecran);
}
clock_t c2 = clock();
 
printf("T1 = %d ms\nT2 = %d ms\n", 
    (((int)(c1-c0))*1000)/CLOCKS_PER_SEC, 
    (((int)(c2-c1))*1000)/CLOCKS_PER_SEC);
 
//attendreTouche();
 
}

@++

[sieuzac]

Juste un truc.
Pourquoi dans le code qui suit TEMP 1 < TEMP 2

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
 
#include <SDL/SDL.h>
#include <stdio.h>
#include <time.h>
#include <string.h>
 
/* surface qui sert à l'affichage dans la mémoire vidéo */
SDL_Surface *ecran = NULL;
 
 
//On crée une surface dans la mémoire système
SDL_Surface *Virtuel = NULL;
 
Uint16 color[1024*768];
 
 
 
 
int main(int argc, char **argv)
{
/* SDL_INIT_VIDEO si besoin de seulement la vidéo */
if (SDL_Init(SDL_INIT_EVERYTHING) == -1)
{
printf("Error: %s\n", SDL_GetError());
return 1;
}
ecran = SDL_SetVideoMode(1024, 768, 16, SDL_HWSURFACE | SDL_DOUBLEBUF | SDL_HWACCEL | SDL_FULLSCREEN);
 
if (ecran == NULL)
{
printf("Error: %s\n", SDL_GetError());
return 1;
}
 
 
int i;
int j;
int k;
int l;
int co1;
int co2;
int co3;
 
 
//TEMP 1
 
for (k = 0; k < 80; k++)
{
    co1 = rand() % 255;
    co2 = rand() % 255;
    co3 = rand() % 255;
 
    Uint16 rgb = SDL_MapRGB(ecran->format, co1, co2, co3);   
    for (i=0; i<1024 ; i++)
    { 
        for (j=0; j<768 ; j++) 
        {
            l = j*1024 + i;
            color[l] = rgb;
        }
    }
 
 
    memcpy((Uint16*)(ecran->pixels),color,1024*768*2);   
    SDL_Flip(ecran);
}
 
 
 
 
 
//TEMP 2
 
for (k = 0; k < 80; k++)
{
    co1 = rand() % 255;
    co2 = rand() % 255;
    co3 = rand() % 255;
 
    Uint16 rgb = SDL_MapRGB(ecran->format, co1, co2, co3);   
    for (i=0; i<1024*768 ; i++) color[i] = rgb;
 
 
 
    memcpy((Uint16*)(ecran->pixels),color,1024*768*2);   
    SDL_Flip(ecran);
}
 
 
}

@+

[fearyourself]

Juste un truc.
Pourquoi dans le code qui suit TEMP 1 < TEMP 2

Je ne sais pas, quels sont les temps que tu as remarqué ?

Jc

[Laurent Gomila]

Pourquoi dans le code qui suit TEMP 1 < TEMP 2

Bizarre. TEMP1 a plus d'instructions, et n'exploite même pas correctement le cache.
Tu peux toujours vérifier l'ASM généré pour voir s'il n'y a pas d'étrangeté.

[sieuzac]

La seul différences entre les deux temps :
Le t1 il y a deux étiquette.
t2 il y a 1 étiquettes.
le petit calcul se trouvant dans t1 est négligeable.

Bien mais lo'rse que l'on calcule une image , on la calcule par a
por a x et y.

mon objectif est de crées une fonction:
void dot(int x, int y, char r, char v, char b);

dout la présentation du t1.

PS:
t1 = 13000ms
t2 = 1800ms

le tout sur 80 img.

voila @++

[Laurent Gomila]

PS:
t1 = 13000ms
t2 = 1800ms

Il y a un zéro de trop, ou bien c'est t2 qui est supérieur à t1 ?

[sieuzac]

non excuse t1 > t2

[Laurent Gomila]

Dans ce cas c'est normal, T1 contient plus d'instructions et est moins "cache-friendly".

[sieuzac]

Oui sa je sais s'est a cause des tableau de donnée que contienne des index.
Je suis en trais de m'orienter vers le principe de allocation mémoire et ainsi de mesurer la vitesse d'adressage.