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

pi1 and paletized pcx loading works. Saving untested, truecolor pcx still broken (but does not crash and preview seems ok ?!)

Browse Source 
git-svn-id: svn://pulkomandy.tk/GrafX2/trunk@109 416bcca6-2ee7-4201-b75f-2eb2f807beb1
This commit is contained in:
Adrien Destugues
2008-08-10 10:25:29 +00:00
parent bf0127e306
commit 216ea8c9c2
5 changed files with 103 additions and 20 deletions
Download Patch File Download Diff File Expand all files Collapse all files

102
op_asm.c
View File

@@ -1,6 +1,23 @@
#include "op_c.h"
#include "stdio.h"
#include "graph.h"
/*************************************************************************************
* Diffusion d'erreur avec l'algorithme de Floyd-Steinberg pour conversion 24b > 256c
* Pour chaque pixel de la source :
* 1) On fait une recherche dans la palette pour trouver la couleurs plus proche
* 2) On calcule la différence avec la vraie couleur
* 3) On répartit cette différence entre les pixels autours avec les coefs:
* - 7/16 pour le pixel de droite
* - 3/16 pour le pixel en bas à gauche
* - 5/16 pour le pixel en dessous
* - 1/16 pour le pixel en bas à droite
* Cette différence est appliquée directement à la source, et sera prise en compte
* lors du traitement des pixels suivants (on ne touche pas aux pixels qui sont au
* dessus ou à gauche de celui en cours !)
************************************************************************************/
void OPASM_DitherFS_6123(
Bitmap256 Destination, // Pointeur sur le 1er pixel de la ligne
Bitmap24B Source, // Idem mais sur la source
@@ -13,7 +30,70 @@ void OPASM_DitherFS_6123(
byte NbbV, // Nb_bits_verts
byte NbbB) // Nb_bits_bleus
{
puts("OPASM_DitherFS_6123 non implémenté!\n");
byte DSFRouge,DSFVert,DSFBleu=0,DSFRougeAD,DSFVertAD,DSFBleuAD;
int VarA;
Bitmap24B PixelCourant, Cible;
// Pour chaque pixel sur la largeur
for(VarA=0;VarA<Largeur;VarA++)
{
PixelCourant = Source + VarA;
// On regarde la meilleure couleur d'après la table de conversion 24b>8b
DSFRougeAD = PixelCourant->R - ReducR;
DSFVertAD = PixelCourant->V - ReducV;
DSFBleuAD = PixelCourant->B - ReducB;
*Destination = *(TableC + DSFRougeAD*256*256 + DSFVertAD*256 + DSFBleu);
// On calcule l'erreur
DSFRouge = PixelCourant->R - Palette[*Destination].R;
DSFVert = PixelCourant->V - Palette[*Destination].V;
DSFBleu = PixelCourant->B - Palette[*Destination].B;
// On diffuse l'erreur sur le pixel de droite (6)
DSFRougeAD = (DSFRouge*7)/16;
DSFVertAD = (DSFVert*7)/16;
DSFBleuAD = (DSFBleu*7)/16;
// Diffusion de l'erreur dans la source
Cible = PixelCourant + 1; // "Pixel à droite"
Cible->R = Max(Cible->R + DSFRougeAD,255);
Cible->V = Max(Cible->V + DSFVertAD,255);
Cible->B = Max(Cible->B + DSFBleuAD,255);
// On diffuse sur le pixel en bas à gauche (1)
DSFRougeAD = (DSFRouge*3)/16;
DSFVertAD = (DSFVert*3)/16;
DSFBleuAD = (DSFBleu*3)/16;
Cible = PixelCourant + Largeur; // "Pixel en bas à gauche"
Cible->R = Max(Cible->R + DSFRougeAD,255);
Cible->V = Max(Cible->V + DSFVertAD,255);
Cible->B = Max(Cible->B + DSFBleuAD,255);
// On diffuse sur le pixel en dessous (2)
DSFRougeAD = (DSFRouge*5)/16;
DSFVertAD = (DSFVert*5)/16;
DSFBleuAD = (DSFBleu*5)/16;
Cible ++; // "Pixel en dessous"
Cible->R = Max(Cible->R + DSFRougeAD,255);
Cible->V = Max(Cible->V + DSFVertAD,255);
Cible->B = Max(Cible->B + DSFBleuAD,255);
// On diffuse sur le pixel en dessous (2)
DSFRougeAD = (DSFRouge*1)/16;
DSFVertAD = (DSFVert*1)/16;
DSFBleuAD = (DSFBleu*1)/16;
Cible ++; // "Pixel en bas à droite"
Cible->R = Max(Cible->R + DSFRougeAD,255);
Cible->V = Max(Cible->V + DSFVertAD,255);
Cible->B = Max(Cible->B + DSFBleuAD,255);
Destination++;
}
}
void OPASM_DitherFS_623(
@@ -28,7 +108,7 @@ void OPASM_DitherFS_623(
byte NbbV, // Nb_bits_verts
byte NbbB) // Nb_bits_bleus
{
puts("OPASM_DitherFS_623 non implémenté!\n");
puts("OPASM_DitherFS_623 non implémenté!");
}
void OPASM_DitherFS_12(
@@ -43,7 +123,7 @@ void OPASM_DitherFS_12(
byte NbbV, // Nb_bits_verts
byte NbbB) // Nb_bits_bleus
{
puts("OPASM_DitherFS_12 non implémenté!\n");
puts("OPASM_DitherFS_12 non implémenté!");
}
void OPASM_DitherFS_6(
@@ -58,7 +138,7 @@ void OPASM_DitherFS_6(
byte NbbV, // Nb_bits_verts
byte NbbB) // Nb_bits_bleus
{
puts("OPASM_DitherFS_6 non implémenté!\n");
puts("OPASM_DitherFS_6 non implémenté!");
}
void OPASM_DitherFS(
@@ -71,7 +151,7 @@ void OPASM_DitherFS_6(
byte NbbV, // Nb_bits_verts
byte NbbB) // Nb_bits_bleus
{
puts("OPASM_DitherFS non implémenté!\n");
puts("OPASM_DitherFS non implémenté!");
}
void OPASM_DitherFS_2(
@@ -86,7 +166,7 @@ void OPASM_DitherFS_2(
byte NbbV, // Nb_bits_verts
byte NbbB) // Nb_bits_bleus
{
puts("OPASM_DitherFS_2 non implémenté!\n");
puts("OPASM_DitherFS_2 non implémenté!");
}
void OPASM_Split_cluster_Rouge(
@@ -104,7 +184,7 @@ void OPASM_DitherFS_2(
int rdec, // rdec
int * rouge) // Valeur du rouge atteignant la limite
{
puts("OPASM_Split_cluster_Rouge non implémenté!\n");
puts("OPASM_Split_cluster_Rouge non implémenté!");
}
void OPASM_Split_cluster_Vert(
@@ -122,7 +202,7 @@ void OPASM_Split_cluster_Vert(
int vdec, // vdec
int * vert) // Valeur du vert atteignant la limite
{
puts("OPASM_Split_cluster_Vert non implémenté!\n");
puts("OPASM_Split_cluster_Vert non implémenté!");
}
void OPASM_Split_cluster_Bleu(
@@ -140,7 +220,7 @@ void OPASM_Split_cluster_Bleu(
int bdec, // bdec
int * bleu) // Valeur du bleu atteignant la limite
{
puts("OPASM_Split_cluster_Bleu non implémenté!\n");
puts("OPASM_Split_cluster_Bleu non implémenté!");
}
void OPASM_Compter_occurences(
@@ -153,7 +233,7 @@ void OPASM_Split_cluster_Bleu(
byte NbbV, // Nb_bits_verts
byte NbbB) // Nb_bits_bleus
{
puts("OPASM_Compter_occurences non implémenté!\n");
puts("OPASM_Compter_occurences non implémenté!");
}
void OPASM_Analyser_cluster(
@@ -172,5 +252,5 @@ void OPASM_Analyser_cluster(
int binc, // Incrémentation sur les bleus 1 << bdec
int * Nbocc) // Nombre d'occurences
{
puts("OPASM_Analyser_cluster non implémenté!\n");
puts("OPASM_Analyser_cluster non implémenté!");
}