scroller efficacement l'ecran - Page 1

J'aurai besoin de fonctions pour scroller l'ecran rapidement pour un programme que je suis en train d'ecrire.
J'ai essaye ScrRectScroll et ScrRectShift qui sont trop lentes pour mes besoins.
J'ai fait quelques essais (ci-dessous) les scrolls verticaux sont acceptables mais les scrolls horyzontaux sont toujours insuffisants.
J'ai vraiment pas d'autres idee, donc merci de votre aide. (petite precision : je ne suis que novice en asm)

Ma methode pour le scroll horyzontal est de shifter tous les words de l'ecran.

#define LINE 30
char *scrollBuffer; // est intialise au debut du programme : malloc(LCD_SIZE-LINE);

void scrollUp(void *ptr) //plutot rapide cette fonction
{
  memcpy(ptr,ptr+LINE,LCD_SIZE-LINE);
}

void scrollDown(void *ptr) //moyennement rapide
{
  //je ne peux pas faire un memcpy direct car la memoire serait remplacee avant d'etre copiee 
  // et passer par un buffer auxiliaire est toujours plus rapide que memmove
  memcpy(scrollBuffer,ptr,LCD_SIZE-LINE);  
  memcpy(ptr+LINE,scrollBuffer,LCD_SIZE-LINE);
}

void scrollLeft(void *screen) //rapidite vraiment merdique :'(
{
  ulint ptr=screen;

  asm{
    movem.l d0-d2/a0,-(a7)
    move.l  ptr,a0
    move.w  #0,d0 //compteur
   whill:
    move.w  (a0),d1
    lsl.w   #1,d1
    addq.l  #2,a0
    move.w  (a0),d2
    and.w   #0x8000,d2
    cmp.w   #0,d2
    beq     elsl
    or.b    #1,d1
   elsl:
    subq.l  #2,a0
    move.w  d1,(a0) //modifie l'ecran
    addq.l  #2,a0  //prochain word a scroller
    addq.w  #1,d0   //incremente le compeur
    cmp.w   #0x780,d0
    bne whill
    movem.l (a7)+,d0-d2/a0
  };
}

void scrollRight(void *screen) //rapidite vraiment merdique :'(
{
  ulint ptr=screen;

  asm{
    movem.l d0-d2/a0,-(a7)
    move.l  ptr,a0
    move.w  #0,d0 //compteur
    move.w  #0,d2
   whilr:
    move.w  (a0),d1
    lsr.w   #1,d1
    cmp.w   #0,d2
    beq elsr
    or.w    #0x8000,d1
   elsr:
    move.w  (a0),d2
    move.w  d1,(a0)
    and.w   #1,d2
    addq.l  #2,a0 //prochain a scroller
    addq.w  #1,d0 //incremente le compeur
    cmp.w   #0x780,d0
    bne whilr
    movem.l (a7)+,d0-d2/a0
  };
}

T'as essayé les routines d'Extgraph ?

Non en fait la je suis en vacances et j'ai acces a un ordinateur que au cyber cafe. GTC Beta
Mais pendant que je suis la je vais regarder ouais.

ben y a extgraph aussi oncalc, c'est juste que ça doit être une vieille version... mais je peux essayer d'en mettre une plus récente si ça intéresse qqun ^^

qques remarques qui me viennent à l'esprit :
[ul][li] bon là en l'occurrence c'est pas critique pour la vitesse, juste pour la taille, mais tu n'as pas besoin d'asm inline, écris juste au niveau global :

asm{
scrollright:
  // a0.l = screen
  ...
  rts
};

(et en plus ça t'évitera les movem, puisque tu auras le droit de détruire d0-d2/a0-a1)
évidemment il faut laisser quand même le prototype C ^^
[li] évite à tout prix les addq #machin,a0 et les subq #machin,a0, ça prend 8 cycles : en l'occurrence tu peux tous les éviter en utilisant (a0)+ à la place de (a0), et -2(a0) pour le dernier ("//modifie l'ecran")
[li] si tu veux faire un scroll rapide, plutôt que de shifter 2 words et passer des heures à essayer de les "recoller" pour faire un word shifté, shifte plutôt un seul long... et en bonus tu pourras faire un shift quelconque tant qu'il fait moins de 8 pixels (en fait ça marche jusqu'à 16 pixels, mais ça finira par devenir lent pour 16 pixels)
[li] pour les boucles, essaye d'utiliser dbra : ça prend 10 cycles par boucle au lieu de 22[/ul]


Sinon pour scrollDown j'utilise dans uview une fonction qui pourrait t'intéresser :

void memmove_even(void *p,void *q,unsigned int size) {
    unsigned int n=size>>3;
    if (p<q) { // forward
#define move4() *((long *)p)++=*((long *)q)++
#define move2() *((int  *)p)++=*((int  *)q)++
        if (n--)
            do
                move4(),move4();
            while (n--);
        if (size&4)
            move4();
        if (size&2)
            move2();
#undef move4
#undef move2
    } else { // backward
        p+=size; q+=size;
#define move4() *--((long *)p)=*--((long *)q)
#define move2() *--((int  *)p)=*--((int  *)q)
        if (n--)
            do
                move4(),move4();
            while (n--);
        if (size&4)
            move4();
        if (size&2)
            move2();
#undef move4
#undef move2
    }
}

Comme tu as l'air de vouloir scroller de 1 pixel à chaque fois, le mieux c'est d'utiliser les instructions 'roxl' et 'roxr', c'est exactement fait pour le scrolling TI
La routine d'Extgraph l'utilise :

void ScrollLeft(unsigned short* buffer,unsigned short lines) {
register short* tmpbuffer = buffer;
register short tmplines = lines;
tmpbuffer += (tmplines*15)+10;
asm volatile (
"0:
and.b #0xee,%%ccr
roxl.w -(%0);roxl.w -(%0);roxl.w -(%0);roxl.w -(%0);roxl.w -(%0)
roxl.w -(%0);roxl.w -(%0);roxl.w -(%0);roxl.w -(%0);roxl.w -(%0)
lea -10(%0),%0;
dbra %1,0b"
: "=a" (tmpbuffer), "=d" (tmplines)
: "0" (tmpbuffer), "1" (tmplines));
}

Après si tu veux faire un scrolling de plusieurs pixels d'un coup, j'ai fait une petite routine en ASM. Elle doit pas être très optimisée, vu que je débute, mais ça peut peut-être servir :

move.l #$4c00,a0
clr.l d1
clr.l d0
move.w #100,d3
move.w #3,d5 // ici tu mets de combien de pixels tu veux scroller ( =< 8 )
clr.l d6
lea mask(pc,d5.w),a1
move.b (a1),d6

label_scroll: // une ligne de TI89 = 5 longs

clr.l d1
move.w #4,d4

label_line: // scrolle un long

move.l (a0),d2
move.l d2,d0
and.l d6,d0
ror.l d5,d0
lsr.l d5,d2
or.l d1,d2
move.l d2,(a0)+
move.l d0,d1

dbra d4,label_line
lea 10(a0),a0
dbra d3,label_scroll

mask dc.b %00000000,%00000001,%00000011,%00000111,%00001111,%00011111,%00111111,%01111111,%11111111

Merci Pollux pour tous tes conseils asm, ils me sont bien utiles (ainsi que ta fonction).

David : J'ai regardé la source de extGraph et j'ai décrouvert ces 2 instructions et j'ai moi aussi fait des fonctions voisines des tiennes.

Merci a vous deux.