From ea8203bb10c3c22f502756a31ef907dc3b177b25 Mon Sep 17 00:00:00 2001 From: Adrien Destugues Date: Wed, 31 Oct 2007 18:14:12 +0000 Subject: [PATCH] Sauvegarde dans l'archive pour reference git-svn-id: svn://pulkomandy.tk/GrafX2/trunk@32 416bcca6-2ee7-4201-b75f-2eb2f807beb1 --- Anciens fichiers/dpmi.asm | 472 ++++++++++++++++++++++++++++++++++ Anciens fichiers/dpmi.h | 20 ++ Anciens fichiers/mcnormal.asm | 227 ++++++++++++++++ Anciens fichiers/mcpourp2.asm | 246 ++++++++++++++++++ 4 files changed, 965 insertions(+) create mode 100644 Anciens fichiers/dpmi.asm create mode 100644 Anciens fichiers/dpmi.h create mode 100644 Anciens fichiers/mcnormal.asm create mode 100644 Anciens fichiers/mcpourp2.asm diff --git a/Anciens fichiers/dpmi.asm b/Anciens fichiers/dpmi.asm new file mode 100644 index 00000000..a09a5659 --- /dev/null +++ b/Anciens fichiers/dpmi.asm @@ -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 diff --git a/Anciens fichiers/dpmi.h b/Anciens fichiers/dpmi.h new file mode 100644 index 00000000..7e525d61 --- /dev/null +++ b/Anciens fichiers/dpmi.h @@ -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 diff --git a/Anciens fichiers/mcnormal.asm b/Anciens fichiers/mcnormal.asm new file mode 100644 index 00000000..82987799 --- /dev/null +++ b/Anciens fichiers/mcnormal.asm @@ -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 diff --git a/Anciens fichiers/mcpourp2.asm b/Anciens fichiers/mcpourp2.asm new file mode 100644 index 00000000..fb2d8f8e --- /dev/null +++ b/Anciens fichiers/mcpourp2.asm @@ -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