FTL Parser 2004 - Page 13

Non, il faut virer le premier ou le deuxième assignement si on est au bord de l'écran. Par exemple (mais c'est probablement assez inefficace fait comme ça, il y a des manières de l'optimiser):
*(pointeur++) |=((x>0)?(*(pic)>>(mask)):0);
*(pointeur) |=((x<232)?(*(pic++)<<(8-mask)):0);

Par contre pour ton optimisation c'est pas bon : c'est carrément plus lent. dans extgraph 1 c'est la même optimisation qui est employé mais c'est moins efficace que ce que j'avais fait.
Donc ça c'est plus lent ...
*(pointeur++) |=*(pic)>>(mask);
*(pointeur) |=*(pic++)<<(8-mask);
que ça :
*(pointeur+1) |=*(pic)<<(8-mask);
*(pointeur++) |=*(pic++)>>(mask);

Tu arrives à voir pourquoi ou bien tu veux le code en asm ?

Je veux le code en ASM.
Et c'est un bogue d'optimisation de GCC. Ma solution devrait être meilleure.

Voici avec ton optimisation :

while(n--)         {                  short mask
	jbra .L21
	.even
.L24:
#L1449	= x_&7;
	move.w %d3,%d1
	and.w #7,%d1
#L1456	*(pointeur++) |=*(pic)>>(mask);
	clr.w %d0
	move.b (%a1),%d0
	asr.w %d1,%d0
	or.b (%a0),%d0
	move.b %d0,(%a0)+
#L1472	*(pointeur) |=*(pic++)<<(8-mask);          //*(pointeur+1) |=*(pic)<<(8-mask);          //*(pointeur++) |=*(pic++)>>(mask);          //*(pointeur++) |=((x_>0)?(*(pic)>>(mask)):0);            //*(pointeur) |=((x_<152)?(*(pic++)<<(8-mask)):0);
	clr.w %d0
	move.b (%a1)+,%d0
	moveq.l #8,%d6
	sub.w %d1,%d6
	lsl.w %d6,%d0
	or.b %d0,(%a0)
#L1498	x_=x_+8;                          }
	addq.w #8,%d3
.L21:
	dbra %d2,.L24
#L1508	y ...
	add.w #256,%d4
	add.w #16,%d5
#L1366	; ...
	addq.w #1,%d7
.L17:
	cmp.w %a2,%d7
	jblt .L25
#L1514	}      //*((char*)LCD_MEM+addr)=x&7;    void _main(void)  {
	movm.l (%sp)+,#0x3cf8
	unlk %a6
	rts

et voici sans :

while(n--)         {                  short mask
	jbra .L21
	.even
.L24:
#L1449	= x_&7;         //*(pointeur++) |=*(pic)>>(mask);         //*(pointeur) |=*(pic++)<<(8-mask);
	move.w %d4,%d2
	and.w #7,%d2
#L1460	*(pointeur+1) |=*(pic)<<(8-mask);
	clr.w %d0
	move.b (%a1),%d0
	moveq.l #8,%d1
	sub.w %d2,%d1
	lsl.w %d1,%d0
	or.b %d0,1(%a0)
#L1479	*(pointeur++) |=*(pic++)>>(mask);          //*(pointeur++) |=((x_>0)?(*(pic)>>(mask)):0);            //*(pointeur) |=((x_<152)?(*(pic++)<<(8-mask)):0);
	clr.w %d0
	move.b (%a1)+,%d0
	asr.w %d2,%d0
	or.b (%a0),%d0
	move.b %d0,(%a0)+
#L1500	x_=x_+8;                          }
	addq.w #8,%d4
.L21:
	dbra %d3,.L24
#L1510	y ...
	add.w #256,%d5
	add.w #16,%d6
#L1366	; ...
	addq.w #1,%a2
.L17:
	move.w %a3,%d0
	cmp.w %a2,%d0
	jbgt .L25
#L1516	}      //*((char*)LCD_MEM+addr)=x&7;    void _main(void)  {
	movm.l (%sp)+,#0x3cf8
	unlk %a6
	rts

Et sinon pour le clipping ça marche très bien comme ceci :

}

       while(n--)
       {
  	     
  	     short mask = x_&7;
  	
  	    *(pointeur+1) |=((x_<232)?(*(pic)<<(8-mask)):0);
  	    *(pointeur) |=((x_>-1)?(*(pic)>>(mask)):0);
            *pic++;
            *pointeur++;
  	     x_=x_+8;
  	     
      
 

Donc les optimisation précédantes ne servent pas à grand chose pour une routine clippée. a moins qu'il y ait des optimisation à faire mais là je n'en vois aucune.

Kevin Kofler :
Hmmm... Encore un problème à déboguer pour moi?

Si tu te mets à considérer ce genre de comportements comme des bugs, alors oui t'as du pain sur la planche et des centaines de bugs à corriger

voilà c'est le truc le plus rapide parmis tout ec que j'ai pû essayer. La routine est au pire des cas 61% plus rapide à celle de l'AMS donc je vais pouvoir prendre celle-là. Je ne pense pas que le clipping en y la ralentisse.

while(n--)
       {
  	     
  	     short mask = x_&7;
  	     if(x_<232)
  	     {
  	     	*(pointeur+1) |=(((*(pic)<<(8-mask))));
  	     }
  	     if(x_>-1)
  	     {
  	     	 *(pointeur) |=((*(pic)>>(mask)));
  	     }
  	     pointeur++;
  	     pic++;
  	     
         
         
  	     x_=x_+8;
  	     
      
       }

Tu peux encore :
- sortir "mask" de la boucle (il ne va pas bouger)
- transformer >-1 en >=0 (peut-être que GCC l'optimise, je sais pas)
- inverser l'ordre des deux modifications de la mémoire
- mettre le "pointeur++" entre les deux et transformer les "pointeur+1" en "pointeur" tout court (parce qu'on aura fait le ++ entre-temps)

Et puis après on peut faire des trucs plus fins pour le clipping, mais c plus chiant.

ok, merci bien je vais essayer tout ça.
Par contre je en comprends pas ton premier truc :

- sortir "mask" de la boucle (il ne va pas bouger)

Alors sinon :

- transformer >-1 en >=0 (peut-être que GCC l'optimise, je sais pas)

Ca a marché avec une réduction de 3 octets en plus.

- inverser l'ordre des deux modifications de la mémoire

Pareil avec une réduction de la taille.

- mettre le "pointeur++" entre les deux et transformer les "pointeur+1" en "pointeur" tout court (parce qu'on aura fait le ++ entre-temps).

Là il ne s'est rien passé par contre. Il faut que je regarde le code ASM.

EDIT : euh mince qu'est-ce que je dit ! Il y a 3 octets en moins donc ça a aussi été optimisé.
Merci Pollux !

Raphaël :
ok, merci bien je vais essayer tout ça.
Par contre je en comprends pas ton premier truc :

- sortir "mask" de la boucle (il ne va pas bouger)

Déplacer "int mask=x_&7" pour le mettre avant la boucle...

Alors sinon :

- transformer >-1 en >=0 (peut-être que GCC l'optimise, je sais pas)

Ca a marché avec une réduction de 3 octets en plus.

3?
Moi je parierais plutôt pour 2 (voire 4)... Je vois pas comment tu peux avoir une réduction impaire.

Déplacer "int mask=x_&7" pour le mettre avant la boucle...

bah oui je suis bête ! il suffit de le faire au début avec x en fait !
Là j'ai encore pas mal gagné en vitesse ! Je suis presque revenu à la même vitesse que quand il n'y avait pas la clipping et la routine est presque 2 fois plus rapide que celle de l'AMS !

Moi je parierais plutôt pour 2 (voire 4)... Je vois pas comment tu peux avoir une réduction impaire.

Non ça doit être 2 partout alors.

Cela dit, 2x plus rapide qu'AMS c pas la gloire non plus

Tu peux largement améliorer le clipping en déterminant avant la boucle quelle zone sera à afficher.

Cela dit, 2x plus rapide qu'AMS c pas la gloire non plus Tu peux largement améliorer le clipping en déterminant avant la boucle quelle zone sera à afficher.

J'ai fait un second mask et puis optimiser un pertit truc et je suis tout près des 2 fois plus. Mais l'image fait juste 49 en longeur et 16 en hauteur. C'est celle du tuto de squale 92. Avec une plus grande image ça ira sûrement plus vite.

Tu peux largement améliorer le clipping en déterminant avant la boucle quelle zone sera à afficher.

Ca je peux le faire en y... et puis en x aussi ouais. de toute façon le clipping ne la ralentit pas tant que ça mais ça vaut le coup de tenter.

Raphaël :
Voici avec ton optimisation :

while(n--)         {                  short mask
	jbra .L21
	.even
.L24:
#L1449	= x_&7;
	move.w %d3,%d1
	and.w #7,%d1
#L1456	*(pointeur++) |=*(pic)>>(mask);
	clr.w %d0
	move.b (%a1),%d0
	asr.w %d1,%d0
	or.b (%a0),%d0
	move.b %d0,(%a0)+
#L1472	*(pointeur) |=*(pic++)<<(8-mask);          //*(pointeur+1) |=*(pic)<<(8-mask);          //*(pointeur++) |=*(pic++)>>(mask);          //*(pointeur++) |=((x_>0)?(*(pic)>>(mask)):0);            //*(pointeur) |=((x_<152)?(*(pic++)<<(8-mask)):0);
	clr.w %d0
	move.b (%a1)+,%d0
	moveq.l #8,%d6
	sub.w %d1,%d6
	lsl.w %d6,%d0
	or.b %d0,(%a0)
#L1498	x_=x_+8;                          }
	addq.w #8,%d3
.L21:
	dbra %d2,.L24
#L1508	y ...
	add.w #256,%d4
	add.w #16,%d5
#L1366	; ...
	addq.w #1,%d7
.L17:
	cmp.w %a2,%d7
	jblt .L25
#L1514	}      //*((char*)LCD_MEM+addr)=x&7;    void _main(void)  {
	movm.l (%sp)+,#0x3cf8
	unlk %a6
	rts

et voici sans :

while(n--)         {                  short mask
	jbra .L21
	.even
.L24:
#L1449	= x_&7;         //*(pointeur++) |=*(pic)>>(mask);         //*(pointeur) |=*(pic++)<<(8-mask);
	move.w %d4,%d2
	and.w #7,%d2
#L1460	*(pointeur+1) |=*(pic)<<(8-mask);
	clr.w %d0
	move.b (%a1),%d0
	moveq.l #8,%d1
	sub.w %d2,%d1
	lsl.w %d1,%d0
	or.b %d0,1(%a0)
#L1479	*(pointeur++) |=*(pic++)>>(mask);          //*(pointeur++) |=((x_>0)?(*(pic)>>(mask)):0);            //*(pointeur) |=((x_<152)?(*(pic++)<<(8-mask)):0);
	clr.w %d0
	move.b (%a1)+,%d0
	asr.w %d2,%d0
	or.b (%a0),%d0
	move.b %d0,(%a0)+
#L1500	x_=x_+8;                          }
	addq.w #8,%d4
.L21:
	dbra %d3,.L24
#L1510	y ...
	add.w #256,%d5
	add.w #16,%d6
#L1366	; ...
	addq.w #1,%a2
.L17:
	move.w %a3,%d0
	cmp.w %a2,%d0
	jbgt .L25
#L1516	}      //*((char*)LCD_MEM+addr)=x&7;    void _main(void)  {
	movm.l (%sp)+,#0x3cf8
	unlk %a6
	rts

Le code avec mon optimisation est nettement meilleur. Presque le même, mais avec un (%a0) (4 cycles) à la place d'un 1(%a0) (8 cycles, 2 octets de plus). C'est ton bench qui était mauvais.

J'ai cru que j'aivais inversé mais non en fait.
pourtant autant des fois il n'y a quasiment pas de différence mais autant là c'était net.
et mon bench il marche bien puisque j'ai testé tout le long la routine avec ça.
Donc c'est bizarre.

Peut-être que tu as inversé en benchant? Vérifie tes benchs... En tout cas, le code C interspersé montre bien que le code en haut est celui avec mon optimisation.

Oui c'est ça je viens de refaie le bench et j'ai dû me planter. Désolé.

Raphaël> Pour le clipping en y, tu n'as pas grand chose à faire, il te suffit juste de réduire le nombre de lignes du bitmap à afficher s'il dépasse de l'écran de façon à ne pas écrire en dehors, et si y<0, il te suffit de "faire commencer" le sprite plus loin e de l'afficher à partir du haut de l'écran. Par exemple, si y=-2 et que ton sprite fait 5 octets de largeur, tu fais sprite+=2*5 et tu commences à l'afficher en haut de l'écran

Et pour le clipping sur x, la méthode que tu utilises n'est pas trop mauvaise, mais tu pourrais sortir du deuxième while dès tu sais que x>232.
Et pareil, tu pourrais ne rentrer dans le while que si x>=0.

D'accord, merci. Hier j'ai fait le clipping en y et il est bon (ça correspond à ce que tu m'explique) mais celui en x est foireux par contre. Ca ne va pas du tout parce-qu'il faudrait tester pour les deux mask en x<0 et x >232 ? Enfin je ne sais pas trop : dans mon programme ça marche assez bien sauf quand l'image est trop grande et qu'elle sort bien de l'écran : on voit des pixels qui apparaissent à l'opposé de l'écran.
Je vais faire ce que tu viens de m'expliquer : de toute façon il ne doit pas y avoir 36 000 façon de le faire.

sinon j'ai un autre souci : certaines images passent très bien et d'autre foire complètement. Des fois en inversant la longeur et la hauteur ça marche mais l'image est dégardé sur le bas... enfin ça vient peut-être de la manière dont les pic sont enregistré ?
Pour faire la routine j'ai pris l'image du tuto de squale 92 pour être sûr que ça marche mais je ne savais pas si ça marche dans tout les cas avec les PIC enregistré depuis la TI ?

Fais tes tests de clipping sur TI-92+

Le problème c'est que si tu ne sors pas de ta boucle quand x>232, à l'itération suivante, la première écriture (qui ne teste que si x est positif) est faite, et ce jusqu'à arriver à la fin du sprite. Et c'est le même principe pour x<0.

Non, mais mon programme supporte la Ti89 et la Ti92+ la taille de l'écran est variable. Et puis je fais tout mes tests avec VTI sur une Rom Ti89 en général. Là j'ai mis 232 mais dans mon programme c'est widht_screen-8.

C'est idiot.
Tu n'as besoin de clipper que selon la taille d'un écran de TI-92+. Même si a fonction tourne sur une 89...

C'est idiot. Tu n'as besoin de clipper que selon la taille d'un écran de TI-92+. Même si a fonction tourne sur une 89...

Justement je pensais le contraire. Les buffers font 3000 octets pour la Ti89 (je trouve que c'est déjà 1000 octets en trop vu la taille de l'écran). En x c'est possible mais ça ne sert à rien d'afficher une partie d'image qui n'est pas dans l'écran ?!
Et puis en y je suis obligé parce-que mon viewer affiche les lignes suivant la taille de l'écran.

Voilà enfin ma routine terminé :

#define height_screen 100
#define width_screen 160
__attribute__((regparm))void PutBitmap(short x, short y,BITMAP* BMP,unsigned char *video_plane)
{
	
  short i=0,j=0;
  short nb_c=BMP->NumCols;
  short nb_l=BMP->NumRows;

  unsigned char *pic=BMP->Data;
  if(y+nb_l>=height_screen) 
  nb_l=height_screen-y; 
  
  short lenght = (nb_c>>3)+1;
  short nb_sprite;
  if(y<0)
  {
  	nb_sprite = -y*lenght;
        pic=pic+nb_sprite;
        nb_l=nb_l+y;
        y=0;
    
  }
  short nb_sprite_out_right =0;
  
  if((x+nb_c)>=width_screen-8)
  {
        nb_sprite_out_right = ((x+nb_c-(width_screen-2))>>3);
  	lenght = lenght-nb_sprite_out_right;
  }
  
  short nb_sprite_out_left=0;
  if(x<0)
  {
  	nb_sprite_out_left=((-1-x)>>3);
  	lenght = lenght - nb_sprite_out_left;
  }
  
  if(lenght<0)
  lenght=0;
  short mask1 = x&7;
  short m=nb_l;
  for(j=0;j<nb_l;j++)
  {
       
       short x_ = x;
       short i=0;
       if(x_<0)
       x_=-1;
       unsigned char *pointeur = (video_plane+(((y<<8)-(y<<4)+x_)>>3));
       /*                                    (256y-16y+x)/8       */
         
       short n=lenght;
       pic=(pic+nb_sprite_out_left);
       while(n--)
       {
  	     
  	       if(x_>=0)
  	     	 *(pointeur) |=((*(pic)>>(mask1)));
  	       pointeur++;
  	       if(x_<width_screen-8)
  	       {
  	     	   *(pointeur) |=(((*(pic)<<(8-mask1))));
  	       }
  	     	
  	       pic++;
  	       x_=x_+8;
      
       }
       y++;
       pic=pic+nb_sprite_out_right;
       
  }

Si vous voyez des erreurs (enfin ça va être très dur à voir) ou des optimisations qui vous sauterais aux yeux, n'hésitez pas à m'en faire part.
J'ai passé très longtemps à débbugé avec VTI parce-que je n'ai pas encore compris grand chose.
Et sinon j'ai toujours le même problème avec certaine PIC qui s'affiche pas correctement du tout... je ne comprends par pourquoi. A mon avais ça peut venir du nombre de colones ou de lignes qui font foiré ma routine et je ne sais pas comment y remédier.

Tu ne calcules pas correctement length. Imagine ton BITMAP fait 16 pixels de largeur, c'est donc codé sur 2 octets. Pourtant ton code renvoie 3 (16/8+1=2+1=3). C'est peut-être ça l'origine de ton problème.

Ouais, ça se pourrait bien, je vais regarder, merci.

La formule correcte est (nb_c+7)>>3.

Voilà je pense avoir faitq uelque chose de correcte...sauf pour la formule : je vais reprendre la tienne Kevin.

 __attribute__((regparm))void PutBitmap(short x, short y,BITMAP* BMP,unsigned char *video_plane)
{
	
  short i=0,j=0;
  short nb_c=BMP->NumCols; // on récupère le nombre de lignes du bitmap
  short nb_l=BMP->NumRows; // on récupère le nombre de colonnes du bitmap

  unsigned char *pic=BMP->Data; // on récupère un pointeur vers le Bitmap lui même
  if(y+nb_l>=height_screen) // si y + nombre de ligne > bas de l'écran
  nb_l=height_screen-y;     // nombre de ligne = bas de l'écran - y.
  short lenght = (nb_c>>3); // on calcule la longeur d'une ligne en octets : nombre de colonnes / 8
  if((lenght*8)!=nb_c) // si la divison comporte un reste on ajout 1
  lenght++;
  short nb_sprite_out_up;
  if(y<0) // si le début du sprite est en dehors de l'écran en haut
  {
  	nb_sprite_out_up = -y*lenght;  // on calcule le nombre de sprite en dehors de l'écran : - le nb de ligne en dehors de l'écran * la longeur d'une ligne en octet
    pic=pic+nb_sprite_out_up;
    nb_l=nb_l+y;
    y=0;
    
  }
  short nb_sprite_out_right =0;
  
  if((x+nb_c)>width_screen+(x&7)-8)
  {
       nb_sprite_out_right = ((x+nb_c-(width_screen+(x&7)))>>3)+1;
  	lenght = lenght-nb_sprite_out_right;
  }
  
  short nb_sprite_out_left=0;
  if(x<0)
  {
  	nb_sprite_out_left=((-1-x)>>3);
  	lenght = lenght - nb_sprite_out_left;
  }
  
  if(lenght<0)
  lenght=0;
  short mask1 = x&7;
  short m=nb_l;
  if(x<0)
  x=-1;
  for(j=0;j<nb_l;j++)
  {
       
       
       short x_ = x;
       short i=0;
       
       unsigned char *pointeur = (video_plane+(((y<<8)-(y<<4)+x_)>>3));
       /*                                    (256y-16y+x)/8       */
         
       short n=lenght;
       pic=(pic+nb_sprite_out_left);
       while(n--)
       {
  	     
  	       if(x_>=0)
  	     	 *(pointeur) |=((*(pic)>>(mask1)));
  	       pointeur++;
  	       if(x_<width_screen-8)
  	       {
  	     	   *(pointeur) |=(((*(pic)<<(8-mask1))));
  	       }
  	     	
  	       pic++;
  	       x_=x_+8;
      
       }
       y++;
       pic=pic+nb_sprite_out_right;
       
  }
  
  
}

Sinon pour le clipping en x du côté droit de l'écran c'est bien plus compliqué que je croyais. Voici le seul truc que j'ai trouvé qui a marché :

if((x+nb_c)>width_screen+(x&7)-8)
  {
        nb_sprite_out_right = ((x+nb_c-(width_screen+(x&7)))>>3)+1;
  	lenght = lenght-nb_sprite_out_right;
  }

Je me suis servi du (x&7), c'était le seul moyen pour qu'il n'y ait plus de bug du genre :
- il manque un pixel au bord avec une certaine abscisse suivant les image.
- ou alors quelque pixels avant d'arriver au bord e l'écran il y a des pixels qui s'affiche entre l'image est le bordde l'écran.
J'ai testé ma routine sur une Ti92+ (VTI) et avec la longeur de l'écran d'une Ti89 pour être sûr à 100 % que ça marche et j'ai essayé avec plusieurs image.
Je sais pas si Seasume, par exemple, tu as clippés les sprites d'extgraph 2 comme ça, mais je ne pensais pas du tout au mask pour le test du clipping. Et j'ai essayé ça par hasard parce-que je en sais même pas qu'elle valeur il contient ni même à quoi il sert exactement !
si ça se peut il faut faire pareil à gauche, non ?

EDIT : finalement ça ne marche pas avec certaine image : il y a toujoursdes proiblème de clipping à droite et je en vois pas trop comment régler ça.

Raphaël :
Je sais pas si Sasume, par exemple, tu as clippés les sprites d'extgraph 2 comme ça, mais je ne pensais pas du tout au mask pour le test du clipping. Et j'ai essayé ça par hasard parce-que je en sais même pas qu'elle valeur il contient ni même à quoi il sert exactement !

Essaie de comprendre quand même ce que tu fais...
Personnellement, je n'utilise pas du tout ça dans extgraph, et je ne comprends pas trop pourquoi tu as eu besoin de faire ça, mais je n'ai pas envie de réfléchir là-dessus, c'est à toi de le faire. J'aurais tendance à penser qu'un (x+nb_c)>=width_screen suffit, mais je ne suis pas sûr, je n'ai pas envie de réfléchir là-dessus, comme je viens de l'écrire c'est à toi de le faire.

si ça se peut il faut faire pareil à gauche, non ?

Ben c'est à toi de voir si tu penses que c'est indispensable ou non... Réfléchis, fais des shémas et tu verras si c'est indispensable. Je trouve ça moyen de programmer au hasard. En tout cas, je doute que j'utiliserai tes programmes si toi-même tu n'es pas sûr de ce que tu fais.

Cette fois c'est bon. en fait tout venait du fait que ej calculais mal le nombre de sprite. Et puis après je n'ai pas pensé à me resservir de la variable lenght et c'est tout.
La routine est finalement 62 % plus rapide que celle de l'AMS (par contre celle de l'AMS peut faire plus de chose et je n'en doute pas ). Donc c'est pas énorme mais là au moins ça ne ralenti plus le viwer comme avant : le scrolling se fait de manière plus naturelle.

__attribute__((regparm))void PutBitmap(short x, short y,BITMAP* BMP,unsigned char *video_plane)
{
	
  short j=0;
  short nb_c=BMP->NumCols; // on récupère le nombre de lignes du bitmap
  short nb_l=BMP->NumRows; // on récupère le nombre de colonnes du bitmap

  unsigned char *pic=BMP->Data; // on récupère un pointeur vers le Bitmap lui même
  if(y+nb_l>=height_screen) // si y + nombre de ligne > bas de l'écran
  nb_l=height_screen-y;     // nombre de ligne = bas de l'écran - y.
  short lenght = ((nb_c+7)>>3); // on calcule la longeur d'une ligne en octets : nombre de colonnes / 8
  short nb_sprite_out_up;
  if(y<0) // si le début du sprite est en dehors de l'écran en haut
  {
  	nb_sprite_out_up = -y*lenght;  // on calcule le nombre de sprite en dehors de l'écran : - le nb de ligne en dehors de l'écran * la longeur d'une ligne en octet
    pic=pic+nb_sprite_out_up;
    nb_l=nb_l+y;
    y=0;
    
  }
  short nb_sprite_out_right =0;
  
  if((x+(lenght<<3))>=width_screen)
  {
       nb_sprite_out_right = ((x+(lenght<<3)-(width_screen))>>3);
  	lenght = lenght-nb_sprite_out_right;
  }
  
  short nb_sprite_out_left=0;
  if(x<0)
  {
  	nb_sprite_out_left=((-1-x)>>3);
  	lenght = lenght - nb_sprite_out_left;
  }
  
  if(lenght<0)
  lenght=0;
  short mask1 = x&7;
  if(x<0)
  x=-1;
  for(j=0;j<nb_l;j++)
  {
       
       
       short x_ = x;
       
       
       unsigned char *pointeur = (video_plane+(((y<<8)-(y<<4)+x_)>>3));
       /*                                    (256y-16y+x)/8       */
         
       short n=lenght;
       pic=(pic+nb_sprite_out_left);
       while(n--)
       {
  	     
  	       if(x_>=0)
  	     	 *(pointeur) |=((*(pic)>>(mask1)));
  	       pointeur++;
  	       if(x_<=width_screen-8)
  	       {
  	     	   *(pointeur) |=(((*(pic)<<(8-mask1))));
  	       }
  	       pic++;
  	       x_=x_+8;
       }
       y++;
       pic=pic+nb_sprite_out_right;
       
  }
  
  
}

Je pense qu'il serait possible d'optimiser encore la routine en sortant le clipping de la boucle :

n=n-2;
if(x_>=0)
*(pointeur) |=((*(pic)>>(mask1)));
pointeur++;
if(x_<=width_screen-8)
*(pointeur) |=(((*(pic)<<(8-mask1))));
pic++;
 x_=x_+8;
while(n--)
       {
  
  	     *(pointeur++) |=((*(pic)>>(mask1)));
  	     *(pointeur) |=(((*(pic++)<<(8-mask1))));
  	       x_=x_+8;
       }
if(x_>=0)
*(pointeur) |=((*(pic)>>(mask1)));
pointeur++;
if(x_<=width_screen-8)
*(pointeur) |=(((*(pic)<<(8-mask1))));
pic++;
x_=x_+8;

J'ai déjà essayé mais évidement ça ne marche pas. Vous pensez que ça serait correcte ? (enfin que le code n'est pas trop lourd ?)

Je pense que c'est une bonne idée si tu veux accélérer ta routine (et ça devrait la ralonger de 20-30 octets maxi).