Comprendre un code asm relatif aux bitmaps

**sorry60** · 19/04/2005, 17h48

Salut à tous,

Je viens de choper sur le net un code asm (en anglais, avecTasm) pour charger une bitmap et l'afficher à l'ecran. Mais je débute en asm et donc je comprend pas tout (meme pas grand chose..

) Et les parties que je comprend, peut etre qu'en réalité je pige de travers

Je vais donc posté quelques parties du code, mettre ce que j'en comprend et si vous avez la gentillesse de me corriger et/ou de me completer, je vous en remercie

Partie1 (en commentaires il s'agit de mes explications donc pas souvent justes

)

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
.model small
.stack 100h              ;declaration de la pile
_DATA segment word public 'DATA'
filename  db   'C:\bmp\UNITS.BMP',0         ;chaine de caractere pour le path de la bitmap
GLEN	    db   'Programmed by Glen Quinn, BINARY SOFTWARE'                 ;signature du programmeur
          db   '$'            ;fin de chaine pour la signature
 
handle    dw   ?                       ;pointeur de fichier FILE * en C
X         dw   ?                         ;simple double word
Y         dw   ?
col       db   640 dup(?)               ;tableau de 640 octets
buff      dw   0                ;la je vois pas trop, peut etre un tableau de 4 cases
          dw   0
          dw   0
          dw   0
multi     dw   6                    ;idem que buff
          dw   4
          dw   0
          dw   0
num       dw   0                    ;variable double word (16 bits ?)
y         dw   409                        ;tableau à 8 cases prérempli ?
          dw   408
          dw   307
          dw   306
          dw   204
          dw   203
          dw   102
          dw   101
 
BMPHEAD    struc                  ;structure bitmap
   id          db   2 dup(?)                ;identifiant => BM pr dire que c'est une bitmap
   filesize    dw   2 dup(?)           ;taille bitmap dans cette variable
   reserved    dw   2 dup(?)                ;à 0
   headersize  dw   2 dup(?)                ;taille de l'entete
   infosize    dw   2 dup(?)                  ;???
   width       dw   2 dup(?)                ;largeur bitmap
   depth       dw   2 dup(?)             ;hauteur
   biplanes    dw   ?                       ;nbr de plans ==> à 0
   bits        dw   ?                          ;nombre de bits par pixel
   bicomp      dw   2 dup(?)            ;compression ==> à 0
   bisizeim    dw   2 dup(?)            ;taille en bits de l'image si pas de compression
   bixpels     dw   2 dup(?)               ;horizontal pixels => à 0
   biypels     dw   2 dup(?)               ;vertical pixels ==> à 0
   biclrused   dw   2 dup(?)               ;nbr de couleurs utilisées 
   biclrimp    dw   2 dup(?)               ;nbr de couleurs "importantes" utilisées
BMPHEAD   ends
 
RGBQUAD   struc                   ;struct RGB
   blue        db   ?                   ;importance du bleu
   green       db   ?                   ;du vert
   red         db   ?                    ;du rouge
   fill        db   ?                        ; reservé, à 0
RGBQUAD   ends
 
params BMPHEAD <>               ;aucune idée
param	 RGBQUAD <>              ;aucune idée
_DATA ends

Voila, j'ai du faire beaucoup d'erreurs

Merci pour vos réponses

**Alcatîz** · 19/04/2005, 19h11

Bonjour !

Pour t'aider à décortiquer les différentes structures, tu peux chercher les détails du format d'un fichier BMP sur le net.
Par exemple : http://www.fortunecity.com/skyscraper/windows/364/bmpffrmt.html

**sorry60** · 19/04/2005, 20h10

ok merci !

et pour le reste j'avais bon ?

J'edit mon 1er message grâce à ton lien

, il me reste encore des ?? notamment

Code :

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

1
2
params BMPHEAD <>               ;aucune idée
param    RGBQUAD <>              ;aucune idée

Je ne vois pas du tout ce que cela peut etre

Encore merci pour ton lien, j'ai appris pleins de choses

**Alcatîz** · 19/04/2005, 22h14

Une bonne introduction aux bitmaps : http://astronomy.swin.edu.au/~pbourke/dataformats/bitmaps/

Envoyé par sorry60

et pour le reste j'avais bon ?

infosize est la taille de la structure BITMAPINFOHEADER.
Pour bisizeim, il y a une nuance : c'est la taille de l'image, habituellement à 0 s'il n'y a pas de compression.
biclrused est habituellement à 0 et c'est le nombre de bits par pixel qui définit le nombre de couleurs.

Pour le reste, je ne sais pas trop : il faudrait voir dans le code l'utilisation qui est faite des différentes variables.

**sorry60** · 20/04/2005, 13h40

Merci pour tes explications.
Voici une autre partie du code qui me laisse assez perplexe

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
 
putpixel	proc	near          ;procedure pour ecrire un pixel à l'ecran
   mov	ax,Y                            ;on met Y dans ax
   mul	multi                            ; ax = ax*multi
   mov	buff,ax                        ;on met ax dans buff
   mov	ax,100                        ;on met 100 dans ax
   mul	buff                             ; ax = ax * buff doncc ax = 100 * multi * Y
   mov	buff,ax                        ;on met ax dans buff
   mov	buff+2,dx                   ;on met dx dans la 2eme case de buff
 
   mov	ax,Y                          ;on met Y dans ax
   mul 	multi+2                      ; ax = ax*multi[2]
   mov	buff+4,ax                  ; on met ax dans buff[4]
   mov	ax,10                        ;on met 10 dans ax
   mul	buff+4                       ; ax = ax*buff[4]
   mov	buff+4,ax                 ;on met ax dans buff[4]
   mov	buff+6,dx                 ;on met buff[6] dans dx
 
   mov	ax,buff                     ;on met buff[0] dans ax
   add	ax,buff+4                  ;on ajoute buff[4]
   mov	buff,ax                     ;on met ax dans buff[0] on a donc fait buff[0] = buff[0] + buff[4]
   mov	ax,buff+2                 ;on met buff[2] dans ax
   adc	ax,buff+6                  ;ax = ax + buff[6] + CF (retenue)
   mov	buff+2,ax                 ;on remet ax dans buff[2]
 
   mov	ax,X                      ;on met X dans ax
   add	buff,ax                   ; ax = ax + buff[0]
   adc	buff+2,0                 ;bizarre...
 
   mov	ax,buff                  ;on met buff[0] dans ax
   mov	dx,buff+2              ;on met buff[2] dans dx
 
   mov	cx,16                    ;on met 16 dans cx
   F1:	sar	dx,1              ;je ne comprend pas trop l'instruction sar
	 rcr	ax,1                ;rcr non plus..
   loop	F1                          ;on repete ca 16fois
   mov	num,ax                 ;on met ax dans num
 
      mov   ax,y                 ;on met y dans ax
      cmp   ax,Y                 ;on compare ax et Y donc y et Y
      je      pass                 ;si c'est egal on saute à pass sinon on continue
 
      mov   ax,y+2
      cmp   ax,Y                 ;on compare y[2] et Y si egal on va à pass
      je      pass                 ;sinon on continue
 
      mov   ax,y+4
      cmp    ax,Y               ;idem avec y[4]
      je	pass
 
      mov   ax,y+6
      cmp   ax,Y                ;idem avec y[6]
      je      pass
 
      mov   ax,y+8
      cmp   ax,Y                 ;idem avec y[8]
      je      pass
 
      mov   ax,y+10
      cmp   ax,Y                   ;idem avec y[10]
      je      pass
 
      mov   ax,y+12
      cmp   ax,Y                    ;idem avec y[12]
      je      pass
 
      mov   ax,y+14
      cmp   ax,Y                 ;on compare Y et y[14]
      jne    bypass            ;si pas egal on saute a bypass sinon on continue
 
pass:                               ;la fameuse etiquette pass
        mov ah,4fh              
	mov al,05h              ;interuption permettant un controle CPU de la fenetre video VESA
	mov bh,00h
	mov bl,00h
	mov dx,num           ;dx contient l'adresse de la memoire video
	int 10h                   ;on lui met num
 
bypass:                         ;etiquette bypass
	mov ax,0A000h      ;on passe a ax l'adresse de l'ecran
	mov es,ax             ;qu'on passe ensuite a es
	mov ax,buff           ;on met buff[0] dans ax
	mov di,ax              ;qu'on met ensuite dans di
	mov al,[si]             ;??????
	stosb                     ;stocke le contenu de AL dans la mémoire d'adresse edi et incr ou decr de 1 unité,je ne comprend pas trop...
	inc si                     ;si++
	ret                        ;fin de cette procédure
	endp

Voila, donc j'ai décris cette fonction dans les commentaires, il doit encore une fois y avoir des erreurs, j'ai eut quelques trous..

Merci pour votre aide

**Alcatîz** · 20/04/2005, 19h21

1. ADC

Code :

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

1
2
add   buff,ax                   ; ax = ax + buff[0] 
adc   buff+2,0                 ;bizarre...

Le but de la seconde instruction est de reporter sur les 16 bits de poids fort de buff la retenue éventuelle de la 1ère addition sur les 16 bits de poids faible.

2. SAR

Code :

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

sar   dx,1              ;je ne comprend pas trop l'instruction sar

SAR sert à la division (signée) par 2 de DX en décalant les bits comme ceci :

Code :

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

1
2
3
4
5
     +--------------------+    +   +
 +---|->x  > > > > > > x--|----|-> | CF
 |   +--|-----------------+    +---+
 |      |                       
 +------+

Le contenu du registre est décalé vers la droite; le bit de poids faible est copié dans le carry flag et le bit de signe est recopié comme bit de poids fort.

3. RCR

Code :

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

rcr   ax,1                ;rcr non plus..

L'instruction est similaire à SAR; une rotation vers la droite est effectuée, en incluant le carry flag :

Code :

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

1
2
3
4
5
     +--------------------+    +   +
 +---|-> > > > > > > > x--|----|-> | CF
 |   +--------------------+    +-|-+
 |                               |
 +-------------------------------+

4. STOSB

Comme tu l'as écrit, cette instruction copie le contenu de AL à l'adresse ES:[DI] puis incrémente ou décrémente DI (pas SI). C'est le direction flag (DF) qui indique si DI est incrémenté (DF = 0) ou décrémenté (DF = 1).
Pour fixer le flag DF, il faut utiliser les instructions CLD (DF = 0) ou STD (DF = 1). L'auteur du code que tu présentes assume peut-être de manière imprudente que DF = 0.