Réponse à etrange pulpe : Je n'ai pas encore regardé en détail, mais à première vue, cela ne devrait pas optimiser en vitesse. Cependant, je vais me pencher sur la question... En tout cas, merci, il fallait être courageux pour regarder le gros bordel que j'ai posté...
Voilà d'ailleurs une édition plus potable...:
;version rapide (Fast VRLE)
;********************************************************
; -Cette routine décompresse les données compressées
; verticalement par pic_z80 de Dan Weiss (Dwedit). C'est une
; adaptation de la routine de décompression que Levi Lansing
; a écrite (TI86) pour utiliser avec son logiciel bmp2asm.
; L'adaptation a été réalisée par joe14 (MYP).
; -(décompresse les données dans le graph buffer - 768 octets)
; -de=adresse de début des données à décompresser
; -registres "détruits" : a,bc,hl,de
;********************************************************
FVRLE:
ld hl,PLOTSSCREEN ;Place le pointeur hl à la première adresse du graph buffer.
FVRLELoop:
ld a,(de) ;Charge le prochain octet à traiter dans a pour faire une comparaison.
inc de ;Avance le pointeur de.
cp $91 ;Regarde si la valeur contenue dans a est un marqueur :
jp z,FVdecinit ;si oui, entame une decompression. Sinon, traite l'octet normalement.
ld (hl),a ;Copie l'octet non compressé dans l'adresse correspondante du
ld bc,12d ;Graph buffer. Prépare le changement de ligne (12 octets par ligne).
add hl,bc ;Fait passer le pointeur hl à l'octet situé au-dessous du précédent.
ld a,h ;Vérifie que le pointeur hl n'a pas dépassé la limite du gbuff.
#ifdef TI83P ;Cette limite étant différente pour chaque calculette et non
cp $96 ;remarquable (sauf sur 86), il existe plusieurs versions de la routine.
#endif
#ifdef TI83
cp $91
#endif
#ifdef TI82
cp $8B
#endif
jp nz,FVRLEloop ;Si le pointeur hl n'a pas dépassé la limite, on retourne à la détection
ld a,l ;de marqueur. Sinon, on détecte une éventuelle fin de décompression.
#ifdef TI83P ;Là aussi, il faut faire des versions différentes.
cp $40
#endif
#ifdef TI83
cp $29
#endif
#ifdef TI82
cp $B8
#endif
jp m,FVRLEloop
ld bc,-767d ;Le pointeur hl ayant dépassé la limite, on soustrait à celui ci le nombre
add hl,bc ;d'octets de l'écran (768) et on incrémente (768+1=767) afin de se placer
ld a,l ;à l'adresse du premier octet de la colonne suivante. On vérifie si le
#ifdef TI83P ;pointeur hl se trouve à l'adresse du second octet de la première colonne.
cp $4C
#endif
#ifdef TI83
cp $35
#endif
#ifdef TI82
cp $C4
#endif
jp nz,FVRLELoop ;Si ce n'est pas le cas, on continue la décompression.
ret ;Si c'est le cas, la décompression est terminée. La routine se termine.
FVdecinit: ;Initialisation de la décompression.
ld a,(de) ;On charge l'octet à recopier dans c.
ld c,a ;
inc de ;Le prochain octet indique combien de fois il faut le recopier.
ld a,(de)
ld b,a ;On le charge dans b afin d'utiliser la commande djnz.On place ensuite
inc de ;le pointeur de sur le prochain octet (qui sera examiné plus tard).
FDCrepeatLoop: ;Boucle de décompression.
ld (hl),c ;On copie l'octet de c dans le graph buffer.
push bc ;On sauvegarde bc afin de l'utiliser dans les opérations suivantes.
ld bc,12d
add hl,bc ;Cela place le pointeur hl sur la ligne suivante.
ld a,h ;On vérifie que hl n'était pas à la dernière ligne du graph buffer
#ifdef TI83P ;avant l'avance de 12.
cp $96
#endif
#ifdef TI83
cp $91
#endif
#ifdef TI82
cp $8B
#endif
jp nz,FDCloop ;Si cela n'est pas le cas, on va à la suite de la boucle.
ld a,l ;On effectue cette comparaison en deux fois, car elle porte sur une
#ifdef TI83P ;adresse (16 bits).
cp $40
#endif
#ifdef TI83
cp $29
#endif
#ifdef TI82
cp $B8
#endif
jp m,FDCloop ;Si cela n'est pas le cas, on va à la suite de la boucle.
ld bc,-767d ;Comme le pointeur hl est en dehors du graph buffer, on le fait changer
add hl,bc ;de colonne et on vérifie qu'il n'était pas à la dernière colonne avant.
ld a,l
#ifdef TI83P
cp $4C ;Lorsque l vaut : TI83+=4Ch, TI83=35h, TI82=C4h, le graph buffer
#endif ;est plein.
#ifdef TI83
cp $35
#endif
#ifdef TI82
cp $C4
#endif
jp nz,FDCloop ;Si l n'est pas égal aux valeurs attendues, on continue la boucle.
pop bc ;Si l est égal aux valeurs attendues, on rétablit bc et
ret ;on retourne à l'endroit d'où a été appelée la routine.
FDCloop:
pop bc ;On rétablit bc pour le djnz et c pour le copier dans hl si la boucle
djnz FDCrepeatLoop ;continue. Relance une boucle de copie de c tant que b est différent
;de zéro. Si b vaut zéro, on effectue la commande suivante.
jp FVRLELoop ;On continue avec le prochain octet (situé actuellement dans de).
