Optimisation affichage 2D

**NiamorH** · 27/03/2007, 18h41

Bonjour,
Je dois afficher en flux continu avec un fps de 24/25 voire plus, une serie d'images tga haute resolution 1900 * 1080

J'aimerai optimiser ma routine d'affichage via OpenGL qui pour le moment est sous la forme et qui ne me donne pas des resultats probants en terme de rapidite:

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
 
glClear (GL_COLOR_BUFFER_BIT);
 
glBegin(GL_POINTS);
  for (uint x = 0; x < im->getLargeur(); ++x)
  {
    for (uint y = 0; y < im->getHauteur(); ++y)
    {	
      uchar r, g , b;
      im->getPixel(x,y,r,g,b);
 
      glColor3ub(r,g,b);
      glVertex2i(x,y);
    }
  }
glEnd();
 
aglSwapBuffers(aglGetCurrentContext());

n'etant pas expert en OpenGL, j'imagine qu'il y a mieux que de faire comme cela... enfin j'espere ?

**Laurent Gomila** · 27/03/2007, 19h10

Je te rassure tout de suite : afficher les pixels un à un en rendu immédiat, c'est le pire que tu pourras faire.

Une meilleure solution serait de mettre à jour une texture dynamique puis de l'afficher sur un carré recouvrant l'écran. Avec les PBO, si ton GPU les supporte, ça peut être suffisamment rapide.

**NiamorH** · 28/03/2007, 11h03

L'idee de la texture est bien. En terme de précision il n'y aura pas de dégradation ou d'interpolation ?

Tu me conseilles aussi de faire de la programmation au niveau carte graphique si je comprend bien ? J'ai très peu d'expérience en la matière.
Qu'est ce qui doit être fait au niveau gpu, le calcul de la texture elle même ou simplement l'application de la texture ?

Etant donné que mon appli doit être portable sur plusieurs machines je dois d'abord tester si la machine supporte la prog sur carte et prevoir une issue de secours.

**Laurent Gomila** · 28/03/2007, 11h18

En terme de précision il n'y aura pas de dégradation ou d'interpolation ?

Dégradation : pas si tu utilises le bon format de pixel (RGB 32 bits j'imagine)
Interpolation : pas si tu désactives le filtrage de texture

Tu me conseilles aussi de faire de la programmation au niveau carte graphique si je comprend bien ? J'ai très peu d'expérience en la matière.
Qu'est ce qui doit être fait au niveau gpu, le calcul de la texture elle même ou simplement l'application de la texture ?

Le remplissage de la texture sera de tout façon fait par le CPU, après tu peux utiliser des extensions comme les PBO pour accélérer le transfert vers la carte graphique.

Etant donné que mon appli doit être portable sur plusieurs machines je dois d'abord tester si la machine supporte la prog sur carte et prevoir une issue de secours.

Ce qui risque de poser problème, hormis les PBO, c'est la taille de texture qui est assez élevée. Au pire tu peux découper en plusieurs sous-textures.

**NiamorH** · 28/03/2007, 13h59

C'est vrai, surtout que les images sont HD...

ok je vais deja tester en appliquant une texture avec cpu.

merci bien. A+

**NiamorH** · 28/03/2007, 15h06

Dis moi, je lis la doc OpenGL sur glTexImage2D et je vois ça :

width Specifies the width of the texture image.
Must be 2n+2(border) for some intege n. All
implementations support texture images that
are at least 64 texels wide.

height Specifies the height of the texture image.
Must be 2m+2(border) for some integer m. All
implementations support texture images that
are at least 64 texels high.

Tous les exemples que je trouve sont pour des textures carrées et de largeur 2^x. Alors je me pose la question est il possible d'appliquer une texture 300*300 par exemple ?

**Laurent Gomila** · 28/03/2007, 15h27

Tous les exemples que je trouve sont pour des textures carrées et de largeur 2^x. Alors je me pose la question est il possible d'appliquer une texture 300*300 par exemple ?

Les textures non carrées, ça fait longtemps que ce n'est plus un problème. Par contre les puissance de deux ça peut en être un, il faut vérifier que la carte supporte l'extension GL_ARB_texture_non_power_of_two.

Si ce n'est pas le cas, tu peux toujours créer des textures puissance de 2 en ajoutant des pixels bidon et en ajustant les coordonnées de texture.

**fearyourself** · 28/03/2007, 15h28

Envoyé par Laurent Gomila

Les textures non carrées, ça fait longtemps que ce n'est plus un problème. Par contre les puissance de deux ça peut en être un, il faut vérifier que la carte supporte l'extension GL_ARB_texture_non_power_of_two.

Si ce n'est pas le cas, tu peux toujours créer des textures puissance de 2 en ajoutant des pixels bidon et en ajustant les coordonnées de texture.

Ou faire des Mipmaps si je ne me trompe pas.

Jc

**bafman** · 28/03/2007, 15h35

en fait, ce n'est pas le fait de faire des mipmap qui resoud les problèmes, mais le fait d'utiliser gluBuild2DMipmap qui va etendre la texture en interne pour qu'elle soit en puissance de 2

**NiamorH** · 28/03/2007, 15h53

ehla je ne comprend plus rien a cette conversation.

Voila ce que j'ai fait :

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
 
uchar* donnees = im->getDonneesPixels();
uchar image[im->getLargeur()][im->getHauteur()][3];
 
// TGA RLE 32
int i, size;
uint compte = 0;
uint lg = (im->getLargeur() * im->getHauteur());
 
while (compte < lg)
{
  size = 1 + (donnees[0] & 0x7f);
 
  if (donnees[0] & 0x80)
  {
    ++donnees;
 
    for (i = 0; i < size; ++i, ++compte)
    {
       image[compte % im->getLargeur()][compte / im->getLargeur()][0] = donnees[2];
       image[compte % im->getLargeur()][compte / im->getLargeur()][1] = donnees[1];
       image[compte % im->getLargeur()][compte / im->getLargeur()][2] = donnees[0];
       //glColor3ub(donnees[2],donnees[1],donnees[0]); // trop lent
       //glVertex2i(compte % im->getLargeur(),compte / im->getLargeur());
    }
    donnees+=4;
  }
  else
  {
    ++donnees;
    for (i = 0; i < size; ++i, ++compte)
    {
      image[compte % im->getLargeur()][compte / im->getLargeur()][0] = donnees[2];
      image[compte % im->getLargeur()][compte / im->getLargeur()][1] = donnees[1];
      image[compte % im->getLargeur()][compte / im->getLargeur()][2] = donnees[0];
      //glColor3ub(donnees[2],donnees[1],donnees[0]); // trop lent
      //glVertex2i(compte % im->getLargeur(),compte / im->getLargeur());
      donnees+=4;
    }
  }
}
 
glBindTexture(GL_TEXTURE_2D,m_visualiseur.m_id_texture);
//glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_NEAREST);
//glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_NEAREST);
glTexImage2D(GL_TEXTURE_2D,0,GL_RGB,im->getLargeur(),im->getHauteur(),0,GL_RGB,GL_UNSIGNED_BYTE,image);
 
glClear (GL_COLOR_BUFFER_BIT);
 
glBegin(GL_QUADS); 
  //glNormal3f(1.0,0.0,0.0);
  glTexCoord2f(0.,0.);   glVertex2i( 0 , 0 );
  glTexCoord2f(1.,0.);   glVertex2i( im->getHauteur() , 0 );
  glTexCoord2f(1.,1.);   glVertex2i( im->getHauteur() , im->getLargeur() );
  glTexCoord2f(0.,1.);   glVertex2i( 0 , im->getLargeur() );
glEnd();

Le resultat me donne un carré de la bonne taille mais tout blanc.
Les images que je tente de charger sont seulement 300*300.

qu'est ce que je ne fais pas bien ? ( glGenTextures(1,&m_id_texture); a été fait plus haut )

**NiamorH** · 28/03/2007, 16h15

d'apres ce que je lis un peu partout, c'est bien dû au fait que les côtés de mon image ne soit pas des puissance de deux. Je vais essayer de faire une texture plus grande mais qui respecte cette regle et jouer ensuite avec glTexCoord2i(0,0); glVertex2i( 0 , 0 ); pour l'adapter a mon ecran.

Au fait quelle plage de valeurs glTexCoord2i attend il ? de 0 a 1 ou de 0 a la taille max de ma texture ??

**NiamorH** · 28/03/2007, 16h25

apparament les filtres de magnifications que j'avais commenté empechaient aussi de loader la texture.

**fearyourself** · 28/03/2007, 16h32

Ton code me semble bizarre, je ne vois pas la différence entre le code du if et le code du else.

Ensuite pourquoi ne pas juste faire deux boucles imbriquées ?

Jc

**razmott** · 28/03/2007, 16h46

Salut !

Pour la différence, dans la deuxième clause le :

donnees += 4;

est en dehors de la boucle. Mais je ne comprends pas non plus le code.

Pourquoi ne pas remplir un tableau de pixel avec deux boucles imbriquées ?

Bon coding !

@+

**NiamorH** · 28/03/2007, 17h06

Salut,

je ne vois pas trop comment faire deux boucles imbriquées avec un codage RLE, mais si tu trouve je veux bien voir comment.
De toute façon l'algo en l'état a une complexité quasi identique non ?

pour info, l'algo est tiré (juste un peu adapté) d'un tuto du site de developpez pour charger une image avec les différents formats TGA, il marche très bien. Peut-être y a-t-il des optimisations à y apporter mais je verrai cela plus tard.

J'ai à priori trouvé la solution à mon problème. Pour une image batarde 234 * 228, je créé une texture à la puissance de deux supérieure la plus proche, 256 dans ce cas et j'adapte mon quad comme ceci :

Code :

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

1
2
3
4
5
6
7
glBegin(GL_QUADS); 
  //glNormal3f(1.0,0.0,0.0);
  glTexCoord2d(0,0);   glVertex2i( 0 , 0 );
  glTexCoord2d((1./256.)*(double)im->getHauteur(),0);   glVertex2i( im->getHauteur() , 0 );
  glTexCoord2d((1./256.)*(double)im->getHauteur(),(1./256.)*(double)im->getLargeur());   glVertex2i( im->getHauteur() , im->getLargeur() );
  glTexCoord2d(0,(1./256.)*(double)im->getLargeur());   glVertex2i( 0 , im->getLargeur() );
glEnd();

Pensez-vous que je puisse avoir des erreurs d'arrondis car je dois être aussi précis que je l'etais avec mes GL_POINTS...

**NiamorH** · 06/04/2007, 15h58

Bonjour,

je poste un petit UP car j'ai des nouvelles.

Je tente d'afficher une sequence d'images HD 1920 / 1080 en boucle.

Je cree tout d'abord une texture 2048 / 2048.
Je la remplit en lisant fichier par fichier.

J'appelle glTexImage2D().

Et enfin je cree un quad et je lui applique la texture.

Tout cela marche sauf que je fait du 4 fps.

Dès que je commente la ligne qui fait glTexImage2D(), j'atteinds 13 fps (bridé maintenant par la lecture sur disque)

Cette instruction est clairement ce qui me freine mon appli alors j'aimerais savoir si il y a des moyens pour l'optimiser (notamment en delegant cet appel a la carte graphique ?? est ce possible ?)

merci

**Laurent Gomila** · 06/04/2007, 16h07

Utilise glTexSubImage2D pour ne pas recréer la texture complétement à chaque fois.

Comme déjà dit, cherche aussi du côté des PBOs.

**NiamorH** · 06/04/2007, 16h48

Je pense que cette methode pourrait me faire gagner quelques fps selon le ratio de l'image mais pour le moment la structure de mon appli ne me permet pas de l'utiliser.

sinon je me documente sur GLSL et je vois ça :

Shader 'Input' Data :

Uniform Variables

sampler2D int Handle for accessing a 2D texture.

Cela veut dire que l'appel à glTexture2D doit etre fait par le proc et je ne peux passer que le HANDLE vers la texture déjà générée non ? parce que dans ce cas, ça n'est pas très interressant pour moi.

**Laurent Gomila** · 06/04/2007, 17h56

Désolé mais j'ai rien compris là

**NiamorH** · 06/04/2007, 18h19

non je n'ai rien dis... je suis pas à l'aise avec les notions de prog carte graphique.

Ne serait-il pas possible de dessiner directement chaque pixel dans le fragment shader ? Serait-ce efficace ?

Et aussi, dans la doc OpenGL je vois marqué ça :

A good OpenGL implementation will render with hardware acceleration whenever possible. However, the implementation is free to not render hardware accelerated. OpenGL doesn't provide a mechanism to ensure that an application is using hardware acceleration, nor to query that it's using hardware acceleration.

De quoi parlent ils ? comment actionne t on cette acceleration materielle ?

Optimisation affichage 2D

OpenGL

Discussions similaires

Partager

Partager