m/grafX2
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Sauvegarde dans l'archive pour reference

Browse Source 
git-svn-id: svn://pulkomandy.tk/GrafX2/trunk@32 416bcca6-2ee7-4201-b75f-2eb2f807beb1
This commit is contained in:
Adrien Destugues 2007-10-31 18:14:12 +00:00
parent ac387ca2ff
commit ea8203bb10
4 changed files with 965 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

472
Anciens fichiers/dpmi.asm Normal file
View File

@ -0,0 +1,472 @@
.386P
.MODEL FLAT
_TEXT Segment dword public 'code'
Assume cs:_TEXT, ds:_DATA
; -- Fonctions DPMI --
public Physical_address_mapping
public Free_physical_address_mapping
public Lock_linear_region
public Unlock_linear_region
public Allocate_ldt_descriptor
public Free_ldt_descriptor
public Set_segment_base_address
public Set_segment_limit
public Set_descriptor_access_rights
public Get_segment_base_address
Physical_address_mapping proc near
push ebp
mov ebp,esp
arg Physical_address:dword,Physical_size:dword,Linear_address_pointer:dword
push ebx
push esi
push edi
; On met dans BX:CX l'adresse physique … mapper
mov eax,Physical_address
mov cx,ax
shr eax,16
mov bx,ax
; On met dans SI:DI la taille de l'adresse physique … mapper
mov eax,Physical_size
mov di,ax
shr eax,16
mov si,ax
; On appelle le service DPMI de mappage d'adresse physique
mov ax,0800h
int 31h
jc Physical_address_mapping_Erreur
; On sauve l'adresse lin‚aire … l'adresse donn‚e
mov eax,Linear_address_pointer
mov [eax+00h],cx
mov [eax+02h],bx
; Et on renvoie un code d'erreur nul
xor ax,ax
Physical_address_mapping_Erreur:
pop edi
pop esi
pop ebx
mov esp,ebp
pop ebp
ret
Physical_address_mapping endp
Free_physical_address_mapping proc near
push ebp
mov ebp,esp
arg Linear_address:dword
push ebx
; On met dans BX:CX l'adresse lin‚aire … d‚mapper
mov eax,Linear_address
mov cx,ax
shr eax,16
mov bx,ax
; On appel le service DPMI de lib‚ration d'un mappage d'adresse physique
mov ax,0801h
int 31h
jc Free_physical_address_mapping_Erreur
; On renvoie un code d'erreur nul
xor ax,ax
Free_physical_address_mapping_Erreur:
pop ebx
mov esp,ebp
pop ebp
ret
Free_physical_address_mapping endp
Lock_linear_region proc near
push ebp
mov ebp,esp
arg Linear_address:dword,Linear_size:dword
push ebx
push esi
push edi
; On met dans BX:CX l'adresse lin‚aire … locker
mov eax,Linear_address
mov cx,ax
shr eax,16
mov bx,ax
; On met dans SI:DI la taille de l'adresse lin‚aire … locker
mov eax,Linear_size
mov di,ax
shr eax,16
mov si,ax
; On appel le service DPMI de lockage d'adresse lin‚aire
mov ax,0600h
int 31h
jc Lock_linear_region_Erreur
; On renvoie un code d'erreur nul
xor ax,ax
Lock_linear_region_Erreur:
pop edi
pop esi
pop ebx
mov esp,ebp
pop ebp
ret
Lock_linear_region endp
Unlock_linear_region proc near
push ebp
mov ebp,esp
arg Linear_address:dword,Linear_size:dword
push ebx
push esi
push edi
; On met dans BX:CX l'adresse lin‚aire … d‚locker
mov eax,Linear_address
mov cx,ax
shr eax,16
mov bx,ax
; On met dans SI:DI la taille de l'adresse lin‚aire … d‚locker
mov eax,Linear_size
mov di,ax
shr eax,16
mov si,ax
; On appel le service DPMI de d‚lockage d'adresse lin‚aire
mov ax,0601h
int 31h
jc Unlock_linear_region_Erreur
; On renvoie un code d'erreur nul
xor ax,ax
Unlock_linear_region_Erreur:
pop edi
pop esi
pop ebx
mov esp,ebp
pop ebp
ret
Unlock_linear_region endp
Allocate_ldt_descriptor proc near
push ebp
mov ebp,esp
arg Nombre_de_descripteurs:word,Base_selector_pointer:dword
push ebx
push esi
push edi
; On met dans CX le nombre de descripteurs ldt … allouer
mov cx,Nombre_de_descripteurs
; On appel le service DPMI d'allocation de descripteurs ldt
mov ax,0000h
int 31h
jc Allocate_ldt_descriptor_Erreur
; On sauve la valeur du s‚lecteur de base
mov ebx,Base_selector_pointer
mov [ebx],ax
; Et on renvoie un code d'erreur nul
xor ax,ax
Allocate_ldt_descriptor_Erreur:
pop edi
pop esi
pop ebx
mov esp,ebp
pop ebp
ret
Allocate_ldt_descriptor endp
Free_ldt_descriptor proc near
push ebp
mov ebp,esp
arg Selector:word
push ebx
push esi
push edi
; On met dans BX le descripteur ldt … lib‚rer
mov bx,Selector
; On appel le service DPMI de lib‚ration de descripteur ldt
mov ax,0001h
int 31h
jc Free_ldt_descriptor_Erreur
; On renvoie un code d'erreur nul
xor ax,ax
Free_ldt_descriptor_Erreur:
pop edi
pop esi
pop ebx
mov esp,ebp
pop ebp
ret
Free_ldt_descriptor endp
Set_segment_base_address proc near
push ebp
mov ebp,esp
arg Selector:word,Linear_base_address:dword
push ebx
; On met dans CX:DX l'adresse de base lin‚aire … assigner au segment
mov eax,Linear_base_address
mov dx,ax
shr eax,16
mov cx,ax
; On met dans BX le s‚lecteur auquel il faut assigner l'adresse de base
mov bx,Selector
; On appel le service DPMI d'assignation d'adresse de base … un segment
mov ax,0007h
int 31h
jc Set_segment_base_address_Erreur
; On renvoie un code d'erreur nul
xor ax,ax
Set_segment_base_address_Erreur:
pop ebx
mov esp,ebp
pop ebp
ret
Set_segment_base_address endp
Set_segment_limit proc near
push ebp
mov ebp,esp
arg Selector:word,Segment_limit:dword
push ebx
; On met dans CX:DX la limite (taille) … assigner au segment
mov eax,Segment_limit
mov dx,ax
shr eax,16
mov cx,ax
; On met dans BX le s‚lecteur auquel il faut assigner une limite
mov bx,Selector
; On appel le service DPMI d'assignation de limite … un segment
mov ax,0008h
int 31h
jc Set_segment_limit_Erreur
; On renvoie un code d'erreur nul
xor ax,ax
Set_segment_limit_Erreur:
pop ebx
mov esp,ebp
pop ebp
ret
Set_segment_limit endp
Set_descriptor_access_rights proc near
push ebp
mov ebp,esp
arg Selector:word,Rights:word
push ebx
; On met dans CX les droits … assigner au segment
mov cx,Rights
; On met dans BX le s‚lecteur auquel il faut assigner des droits
mov bx,Selector
; On appel le service DPMI d'assignation de droits … un segment
mov ax,0009h
int 31h
jc Set_descriptor_access_rights_Erreur
; On renvoie un code d'erreur nul
xor ax,ax
Set_descriptor_access_rights_Erreur:
pop ebx
mov esp,ebp
pop ebp
ret
Set_descriptor_access_rights endp
Get_segment_base_address proc near
push ebp
mov ebp,esp
arg Selector:word,Linear_base_address_pointer:dword
push ebx
; On met dans BX le s‚lecteur dont il faut lire l'adresse de base
mov bx,Selector
; On appel le service DPMI de lecture d'adresse de base d'un segment
mov ax,0006h
int 31h
jc Get_segment_base_address_Erreur
; On sauve l'adresse de base lin‚aire du segment
mov eax,Linear_base_address_pointer
mov [eax+00h],dx
mov [eax+02h],cx
; On renvoie un code d'erreur nul
xor ax,ax
Get_segment_base_address_Erreur:
pop ebx
mov esp,ebp
pop ebp
ret
Get_segment_base_address endp
_TEXT ENDS
END

20
Anciens fichiers/dpmi.h Normal file
View File

@ -0,0 +1,20 @@
#ifndef _DPMI_H_
#define _DPMI_H_
word Physical_address_mapping(byte * Physical_address,dword Size,byte * * Linear_address_pointer);
word Free_physical_address_mapping(byte * Linear_address);
word Lock_linear_region(byte * Linear_address,dword Size);
word Unlock_linear_region(byte * Linear_address,dword Size);
word Allocate_ldt_descriptor(word Nombre_de_descripteurs,word * Base_selector_pointer);
word Free_ldt_descriptor(word Selector);
word Set_segment_base_address(word Selector,byte * Linear_base_address);
word Set_segment_limit(word Selector,dword Segment_limit);
word Set_descriptor_access_rights(word Selector,word Rights);
word Get_segment_base_address(word Selector,byte * * Linear_base_address_pointer);
#endif

227
Anciens fichiers/mcnormal.asm Normal file
View File

@ -0,0 +1,227 @@
; -- Calcul de la meilleure couleur s'approchant d'une teinte particuliŠre --
Meilleure_couleur proc near
push ebp
mov ebp,esp
arg Rouge:byte,Vert:byte,Bleu:byte
push ebx
push esi
push edi
; On place dans ESI l'adresse de la palette
mov esi,offset Principal_Palette
; On place l'indice de la couleur au d‚but de la table d'exclusion de coul.
mov MC_Indice,offset Exclude_color
; EDI servira … stocker la meilleure diff‚rence
mov edi,07FFFFFFFh
; On se sert de CL pour compter la couleur en cours
; (et CH servira … stocker la meilleure couleur)
xor cx,cx
; On nettoie la partie haute de EAX:
xor eax,eax
Meilleure_couleur_Pour_chaque_couleur:
; On v‚rifie que la couleur ne soit pas exclue
mov ebx,MC_Indice
cmp byte ptr [ebx],0
jnz Meilleure_couleur_Pas_mieux
; EBX sert … pointer la table pr‚calcul‚e
mov ebx,MC_Table_differences
; On calcule la diff‚rence:
;
; Le calcul s'effectue dans EDX (on y cumule les diff‚rences), en se
; servant de EBX pour pointer la table pr‚calcul‚e, et de AX comme
; indice dans la table
; On s'occupe de la composante Rouge
mov al,[esi]
mov dl,[esi+1] ; et en entrelac‚ de la composante verte
mov ah,Rouge
mov dh,Vert
sub al,ah
sub dl,dh
and eax,127
and edx,127
mov edx,[ebx+4*edx+128*4]
add edx,[ebx+4*eax]
; On s'occupe de la composante Bleue
mov al,[esi+2]
mov ah,Bleu
sub al,ah
and eax,127
add edx,[ebx+4*eax+256*4]
jz Meilleure_couleur_Correspond_impeccablement
cmp edx,edi
jae Meilleure_couleur_Pas_mieux
; L…, on sait que CL contient une meilleure couleur que CH
mov ch,cl ; On commence par mettre CH … CL
mov edi,edx ; Ensuite, on peut mettre DI (meilleure diff‚rence) … jour
Meilleure_couleur_Pas_mieux:
inc MC_Indice
add esi,3
inc cl
jnz Meilleure_couleur_Pour_chaque_couleur
; Ici, on sait que CH contient d‚j… la meilleure couleur. On va donc faire
; une sortie rapide (c'est pas bien, mais ‡a fait gagner 3 cycles)
mov al,ch
pop edi
pop esi
pop ebx
mov esp,ebp
pop ebp
ret
Meilleure_couleur_Correspond_impeccablement:
; Ici, on sait que CL contient la couleur qui correspond exactement aux
; exigences de l'appelant
mov al,cl
pop edi
pop esi
pop ebx
mov esp,ebp
pop ebp
ret
Meilleure_couleur endp
; -- Calcul de la meilleure couleur s'approchant d'une teinte particuliŠre --
; -- et ceci SANS exclure certaines couleurs coch‚es par l'utilisateur --
Meilleure_couleur_sans_exclusion proc near
push ebp
mov ebp,esp
arg Rouge:byte,Vert:byte,Bleu:byte
push ebx
push esi
push edi
; On place dans ESI l'adresse de la palette
mov esi,offset Principal_Palette
; EDI servira … stocker la meilleure diff‚rence
mov edi,07FFFFFFFh
; On se sert de CL pour compter la couleur en cours
; (et CH servira … stocker la meilleure couleur)
xor cx,cx
; On nettoie la partie haute de EAX:
xor eax,eax
; EBX sert … pointer la table pr‚calcul‚e
mov ebx,MC_Table_differences
MCSE_Pour_chaque_couleur:
; On calcule la diff‚rence:
;
; Le calcul s'effectue dans EDX (on y cumule les diff‚rences), en se
; servant de EBX pour pointer la table pr‚calcul‚e, et de AX comme
; indice dans la table
; On s'occupe de la composante Rouge
mov al,[esi]
mov dl,[esi+1] ; et en entrelac‚ de la composante verte
mov ah,Rouge
mov dh,Vert
sub al,ah
sub dl,dh
and eax,127
and edx,127
mov edx,[ebx+4*edx+128*4]
add edx,[ebx+4*eax]
; On s'occupe de la composante Bleue
mov al,[esi+2]
mov ah,Bleu
sub al,ah
and eax,127
add edx,[ebx+4*eax+256*4]
jz MCSE_Correspond_impeccablement
cmp edx,edi
jae MCSE_Pas_mieux
; L…, on sait que CL contient une meilleure couleur que CH
mov ch,cl ; On commence par mettre CH … CL
mov edi,edx ; Ensuite, on peut mettre DI (meilleure diff‚rence) … jour
MCSE_Pas_mieux:
add esi,3
inc cl
jnz MCSE_Pour_chaque_couleur
; Ici, on sait que CH contient d‚j… la meilleure couleur. On va donc faire
; une sortie rapide (c'est pas bien, mais ‡a fait gagner 3 cycles)
mov al,ch
pop edi
pop esi
pop ebx
mov esp,ebp
pop ebp
ret
MCSE_Correspond_impeccablement:
; Ici, on sait que CL contient la couleur qui correspond exactement aux
; exigences de l'appelant
mov al,cl
pop edi
pop esi
pop ebx
mov esp,ebp
pop ebp
ret
Meilleure_couleur_sans_exclusion endp

246
Anciens fichiers/mcpourp2.asm Normal file
View File

@ -0,0 +1,246 @@
; -- Calcul de la meilleure couleur s'approchant d'une teinte particuliŠre --
Meilleure_couleur proc near
push ebp
mov ebp,esp
arg Rouge:byte,Vert:byte,Bleu:byte
push ebx
push esi
push edi
; On place dans ESI l'adresse de la palette
mov esi,offset Principal_Palette
; On place l'indice de la couleur au d‚but de la table d'exclusion de coul.
mov MC_Indice,offset Exclude_color
; EDI servira … stocker la meilleure diff‚rence
mov edi,07FFFFFFFh
; On se sert de CL pour compter la couleur en cours
; (et CH servira … stocker la meilleure couleur)
xor cx,cx
Meilleure_couleur_Pour_chaque_couleur:
mov ebx,MC_Indice
cmp byte ptr [ebx],0
jnz Meilleure_couleur_Pas_mieux
; On calcule la diff‚rence:
; On s'occupe de la composante Rouge
xor ebx,ebx
xor eax,eax
mov bl,[esi]
mov al,Rouge
sub eax,ebx
imul eax
mov MC_DR,eax
; On s'occupe de la composante Verte
xor ebx,ebx
xor eax,eax
mov bl,[esi+1]
mov al,Vert
sub eax,ebx
imul eax
mov MC_DV,eax
; On s'occupe de la composante Bleue
xor ebx,ebx
xor eax,eax
mov bl,[esi+2]
mov al,Bleu
sub eax,ebx
imul eax
mov MC_DB,eax
; On totalise la "distance" dans EBX
mov eax,30
mul MC_DR
mov ebx,eax
mov eax,59
mul MC_DV
add ebx,eax
mov eax,11
mul MC_DB
add ebx,eax
jz Meilleure_couleur_Correspond_impeccablement
cmp ebx,edi
jae Meilleure_couleur_Pas_mieux
; L…, on sait que CL contient une meilleure couleur que CH
mov ch,cl ; On commence par mettre CH … CL
mov edi,ebx ; Ensuite, on peut mettre DI (meilleure diff‚rence) … jour
Meilleure_couleur_Pas_mieux:
inc MC_Indice
add esi,3
inc cl
jnz Meilleure_couleur_Pour_chaque_couleur
; Ici, on sait que CH contient d‚j… la meilleure couleur. On va donc faire
; une sortie rapide (c'est pas bien, mais ‡a fait gagner 3 cycles)
mov al,ch
pop edi
pop esi
pop ebx
mov esp,ebp
pop ebp
ret
Meilleure_couleur_Correspond_impeccablement:
; Ici, on sait que CL contient la couleur qui correspond exactement aux
; exigences de l'appelant
mov al,cl
pop edi
pop esi
pop ebx
mov esp,ebp
pop ebp
ret
Meilleure_couleur endp
; -- Calcul de la meilleure couleur s'approchant d'une teinte particuliŠre --
; -- et ceci SANS exclure certaines couleurs coch‚es par l'utilisateur --
Meilleure_couleur_sans_exclusion proc near
push ebp
mov ebp,esp
arg Rouge:byte,Vert:byte,Bleu:byte
push ebx
push esi
push edi
; On place dans ESI l'adresse de la palette
mov esi,offset Principal_Palette
; EDI servira … stocker la meilleure diff‚rence
mov edi,07FFFFFFFh
; On se sert de CL pour compter la couleur en cours
; (et CH servira … stocker la meilleure couleur)
xor cx,cx
MCSE_Pour_chaque_couleur:
; On calcule la diff‚rence:
; On s'occupe de la composante Rouge
xor ebx,ebx
xor eax,eax
mov bl,[esi]
mov al,Rouge
sub eax,ebx
imul eax
mov MC_DR,eax
; On s'occupe de la composante Verte
xor ebx,ebx
xor eax,eax
mov bl,[esi+1]
mov al,Vert
sub eax,ebx
imul eax
mov MC_DV,eax
; On s'occupe de la composante Bleue
xor ebx,ebx
xor eax,eax
mov bl,[esi+2]
mov al,Bleu
sub eax,ebx
imul eax
mov MC_DB,eax
; On totalise la "distance" dans EBX
mov eax,30
mul MC_DR
mov ebx,eax
mov eax,59
mul MC_DV
add ebx,eax
mov eax,11
mul MC_DB
add ebx,eax
jz MCSE_Correspond_impeccablement
cmp ebx,edi
jae MCSE_Pas_mieux
; L…, on sait que CL contient une meilleure couleur que CH
mov ch,cl ; On commence par mettre CH … CL
mov edi,ebx ; Ensuite, on peut mettre DI (meilleure diff‚rence) … jour
MCSE_Pas_mieux:
add esi,3
inc cl
jnz MCSE_Pour_chaque_couleur
; Ici, on sait que CH contient d‚j… la meilleure couleur. On va donc faire
; une sortie rapide (c'est pas bien, mais ‡a fait gagner 3 cycles)
mov al,ch
pop edi
pop esi
pop ebx
mov esp,ebp
pop ebp
ret
MCSE_Correspond_impeccablement:
; Ici, on sait que CL contient la couleur qui correspond exactement aux
; exigences de l'appelant
mov al,cl
pop edi
pop esi
pop ebx
mov esp,ebp
pop ebp
ret
Meilleure_couleur_sans_exclusion endp