You can now move windows.
Warning, floyd steinberg dithering disabled for debugging purposes git-svn-id: svn://pulkomandy.tk/GrafX2/trunk@116 416bcca6-2ee7-4201-b75f-2eb2f807beb1
This commit is contained in:
Adrien Destugues
parent
d9cc87b669
commit
48cadad912
17
loadsave.c
17
loadsave.c
@ -3556,15 +3556,20 @@ void Load_PCX(void)
|
||||
|
||||
// On se positionne à la fin du fichier - 769 octets pour voir s'il y
|
||||
// a une palette.
|
||||
if ( (Header.Depth==8) && (Header.Version>=5) && (Taille_du_fichier>sizeof(T_Palette)) )
|
||||
if ( (Header.Depth==8) && (Header.Version>=5) && (Taille_du_fichier>(256*3)) )
|
||||
{
|
||||
lseek(Fichier,Taille_du_fichier-(sizeof(T_Palette)+1),SEEK_SET);
|
||||
// On regarde s'il y a une palette aprŠs les données de l'image
|
||||
lseek(Fichier,Taille_du_fichier-((256*3)+1),SEEK_SET);
|
||||
// On regarde s'il y a une palette après les données de l'image
|
||||
if (read(Fichier,&Octet1,1)==1)
|
||||
if (Octet1==12) // Lire la palette si c'est une image en 256 couleurs
|
||||
{
|
||||
int indice;
|
||||
// On lit la palette 256c que ces crétins ont foutue à la fin du fichier
|
||||
if (read(Fichier,Principal_Palette,sizeof(T_Palette))!=sizeof(T_Palette))
|
||||
for(indice=0;indice<256;indice++);
|
||||
if ((read(Fichier,&Principal_Palette[indice].R,1)!=1)
|
||||
|| (read(Fichier,&Principal_Palette[indice].V,1)!=1)
|
||||
|| (read(Fichier,&Principal_Palette[indice].B,1)!=1))
|
||||
|
||||
Erreur_fichier=2;
|
||||
}
|
||||
}
|
||||
@ -3573,8 +3578,8 @@ void Load_PCX(void)
|
||||
Remapper_fileselect();
|
||||
|
||||
// Maintenant qu'on a lu la palette que ces crétins sont allés foutre
|
||||
// à la fin, on retourne juste aprŠs le header pour lire l'image.
|
||||
lseek(Fichier,sizeof(struct PCX_Header),SEEK_SET);
|
||||
// à la fin, on retourne juste après le header pour lire l'image.
|
||||
lseek(Fichier,128,SEEK_SET);
|
||||
|
||||
if (!Erreur_fichier)
|
||||
{
|
||||
|
||||
1
moteur.c
1
moteur.c
@ -1616,6 +1616,7 @@ void Deplacer_fenetre(short Dx, short Dy)
|
||||
Menu_visible=B;
|
||||
for (Indice=0; Indice<Hauteur; Indice++)
|
||||
Afficher_ligne(Nouveau_X,Nouveau_Y+Indice,Largeur,Buffer+((int)Indice*Largeur));
|
||||
SDL_UpdateRect(Ecran_SDL,Nouveau_X,Nouveau_Y,Largeur,Hauteur);
|
||||
Fenetre_Pos_X=Nouveau_X;
|
||||
Fenetre_Pos_Y=Nouveau_Y;
|
||||
}
|
||||
|
||||
5
op_asm.c
5
op_asm.c
@ -1,5 +1,5 @@
|
||||
#include "op_c.h"
|
||||
#include "stdio.h"
|
||||
#include <stdio.h>
|
||||
|
||||
#include "graph.h"
|
||||
|
||||
@ -96,6 +96,9 @@ void OPASM_DitherFS_6123(
|
||||
|
||||
}
|
||||
|
||||
/* Les fonctions ci-dessous servent pour les pixels des bords et des coins, car on ne peut pas les traiter normalement
|
||||
* (segfault ou dithering sur l'autre bout de l'image) */
|
||||
|
||||
void OPASM_DitherFS_623(
|
||||
Bitmap256 Destination, // Pointeur sur le 1er pixel de la ligne
|
||||
Bitmap24B Source, // Idem mais sur la source
|
||||
|
||||
57
op_c.c
57
op_c.c
@ -6,6 +6,7 @@
|
||||
#include <sys/stat.h>
|
||||
#include "op_c.h"
|
||||
#include "op_asm.h"
|
||||
#include "erreurs.h"
|
||||
|
||||
#undef OPTIMISATIONS_ASSEMBLEUR
|
||||
|
||||
@ -137,10 +138,16 @@ byte TC_Get(Table_conversion * t,int r,int v,int b)
|
||||
{
|
||||
int indice;
|
||||
|
||||
// On réduit le nombre de bits par couleur
|
||||
r=(r>>t->red_r);
|
||||
v=(v>>t->red_v);
|
||||
b=(b>>t->red_b);
|
||||
|
||||
// On recherche la couleur la plus proche dans la table de conversion
|
||||
indice=(r<<t->dec_r) | (v<<t->dec_v) | (b<<t->dec_b);
|
||||
|
||||
if(r!=0 && v != 0 && b != 0)
|
||||
printf("%d %d %d %d\n",indice,r,v,b);
|
||||
return t->table[indice];
|
||||
}
|
||||
|
||||
@ -881,9 +888,11 @@ Table_conversion * Optimiser_palette(Bitmap24B image,int taille,struct Composant
|
||||
ClusterSet * cs;
|
||||
DegradeSet * ds;
|
||||
|
||||
// Cr‚ation des ‚l‚ments n‚cessaires au calcul de palette optimis‚e:
|
||||
// Création des éléments nécessaires au calcul de palette optimisée:
|
||||
to=0; tc=0; cs=0; ds=0;
|
||||
|
||||
DEBUG("START OPTIMIZING",1);
|
||||
|
||||
to=TO_New(r,v,b);
|
||||
if (to!=0)
|
||||
{
|
||||
@ -919,6 +928,8 @@ Table_conversion * Optimiser_palette(Bitmap24B image,int taille,struct Composant
|
||||
}
|
||||
TO_Delete(to);
|
||||
}
|
||||
// Si on arrive ici c'est que l'allocation n'a pas réussi,
|
||||
// l'appelant devra recommencer avec une précision plus faible (3 derniers paramètres)
|
||||
return 0;
|
||||
}
|
||||
|
||||
@ -930,22 +941,24 @@ Table_conversion * Optimiser_palette(Bitmap24B image,int taille,struct Composant
|
||||
#ifdef OPTIMISATIONS_ASSEMBLEUR
|
||||
|
||||
void Convert_bitmap_24B_to_256_Floyd_Steinberg(Bitmap256 dest,Bitmap24B source,int largeur,int hauteur,struct Composantes * palette,Table_conversion * tc)
|
||||
// Cette fonction d‚grade au fur et … mesure le bitmap source, donc soit on ne
|
||||
// s'en ressert pas, soit on passe … la fonction une copie de travail du
|
||||
// Cette fonction dégrade au fur et à mesure le bitmap source, donc soit on ne
|
||||
// s'en ressert pas, soit on passe à la fonction une copie de travail du
|
||||
// bitmap original.
|
||||
{
|
||||
Bitmap24B courant;
|
||||
Bitmap256 d;
|
||||
int y;
|
||||
|
||||
|
||||
// On initialise les variables de parcours:
|
||||
courant=source;
|
||||
d =dest;
|
||||
|
||||
if ((largeur>0) && (hauteur>0))
|
||||
{ if (hauteur>1)
|
||||
{
|
||||
// Traitement de la 1Šre ligne … l'avant-derniŠre
|
||||
if (hauteur>1)
|
||||
{
|
||||
// Traitement de la 1ère ligne à l'avant-dernière
|
||||
|
||||
if (largeur>1)
|
||||
{
|
||||
@ -1016,8 +1029,8 @@ int Valeur_modifiee(int valeur,int modif)
|
||||
}
|
||||
|
||||
void Convert_bitmap_24B_to_256_Floyd_Steinberg(Bitmap256 Dest,Bitmap24B Source,int largeur,int hauteur,struct Composantes * palette,Table_conversion * tc)
|
||||
// Cette fonction d‚grade au fur et … mesure le bitmap source, donc soit on ne
|
||||
// s'en ressert pas, soit on passe … la fonction une copie de travail du
|
||||
// Cette fonction dégrade au fur et à mesure le bitmap source, donc soit on ne
|
||||
// s'en ressert pas, soit on passe à la fonction une copie de travail du
|
||||
// bitmap original.
|
||||
{
|
||||
Bitmap24B Courant;
|
||||
@ -1032,11 +1045,11 @@ void Convert_bitmap_24B_to_256_Floyd_Steinberg(Bitmap256 Dest,Bitmap24B Source,i
|
||||
int ERouge,EVert,EBleu;
|
||||
|
||||
// On initialise les variables de parcours:
|
||||
Courant =Source;
|
||||
Suivant =Courant+largeur;
|
||||
C_plus1 =Courant+1;
|
||||
S_moins1=Suivant-1;
|
||||
S_plus1 =Suivant+1;
|
||||
Courant =Source; // Le pixel dont on s'occupe
|
||||
Suivant =Courant+largeur; // Le pixel en dessous
|
||||
C_plus1 =Courant+1; // Le pixel à droite
|
||||
S_moins1=Suivant-1; // Le pixel en bas à gauche
|
||||
S_plus1 =Suivant+1; // Le pixel en bas à droite
|
||||
D =Dest;
|
||||
|
||||
// On parcours chaque pixel:
|
||||
@ -1050,13 +1063,13 @@ void Convert_bitmap_24B_to_256_Floyd_Steinberg(Bitmap256 Dest,Bitmap24B Source,i
|
||||
Vert =Courant->V;
|
||||
Bleu =Courant->B;
|
||||
*D=TC_Get(tc,Rouge,Vert,Bleu);
|
||||
|
||||
// Puis on calcule pour chaque composante l'erreur d–e … l'approximation
|
||||
/*
|
||||
// Puis on calcule pour chaque composante l'erreur dûe à l'approximation
|
||||
Rouge=Rouge-palette[*D].R;
|
||||
Vert =Vert -palette[*D].V;
|
||||
Bleu =Bleu -palette[*D].B;
|
||||
|
||||
// On initialise la quantit‚ d'erreur diffus‚e
|
||||
// On initialise la quantité d'erreur diffusée
|
||||
DRouge=Rouge;
|
||||
DVert =Vert;
|
||||
DBleu =Bleu;
|
||||
@ -1075,7 +1088,7 @@ void Convert_bitmap_24B_to_256_Floyd_Steinberg(Bitmap256 Dest,Bitmap24B Source,i
|
||||
DRouge-=ERouge;
|
||||
DVert -=EVert;
|
||||
DBleu -=EBleu;
|
||||
// En bas … gauche:
|
||||
// En bas à gauche:
|
||||
if (Pos_Y+1<hauteur)
|
||||
{
|
||||
ERouge=(Rouge*3)/16;
|
||||
@ -1100,7 +1113,7 @@ void Convert_bitmap_24B_to_256_Floyd_Steinberg(Bitmap256 Dest,Bitmap24B Source,i
|
||||
DRouge-=ERouge;
|
||||
DVert -=EVert;
|
||||
DBleu -=EBleu;
|
||||
// En bas … droite:
|
||||
// En bas à droite:
|
||||
if (Pos_X+1<largeur)
|
||||
{
|
||||
S_plus1->R=Valeur_modifiee(S_plus1->R,DRouge);
|
||||
@ -1108,7 +1121,7 @@ void Convert_bitmap_24B_to_256_Floyd_Steinberg(Bitmap256 Dest,Bitmap24B Source,i
|
||||
S_plus1->B=Valeur_modifiee(S_plus1->B,DBleu );
|
||||
}
|
||||
}
|
||||
|
||||
*/
|
||||
// On passe au pixel suivant :
|
||||
Courant++;
|
||||
C_plus1++;
|
||||
@ -1137,15 +1150,15 @@ static const byte precision_24b[]=
|
||||
3,3,2};
|
||||
|
||||
|
||||
// Convertie avec le plus de pr‚cision possible une image 24b en 256c
|
||||
// Convertie avec le plus de précision possible une image 24b en 256c
|
||||
// Renvoie s'il y a eu une erreur ou pas..
|
||||
int Convert_bitmap_24B_to_256(Bitmap256 Dest,Bitmap24B Source,int largeur,int hauteur,struct Composantes * palette)
|
||||
{
|
||||
Table_conversion * table; // table de conversion
|
||||
int ip; // Indice de pr‚cision pour la conversion
|
||||
int ip; // Indice de précision pour la conversion
|
||||
|
||||
// On essaye d'obtenir une table de conversion qui loge en m‚moire, avec la
|
||||
// meilleure pr‚cision possible
|
||||
// On essaye d'obtenir une table de conversion qui loge en mémoire, avec la
|
||||
// meilleure précision possible
|
||||
for (ip=0;ip<(10*3);ip+=3)
|
||||
{
|
||||
table=Optimiser_palette(Source,largeur*hauteur,palette,precision_24b[ip+0],
|
||||
|
||||
70
op_c.h
70
op_c.h
@ -3,64 +3,64 @@
|
||||
|
||||
#include "struct.h"
|
||||
|
||||
//////////////////////////////////////////////// D‚finition des types de base
|
||||
//////////////////////////////////////////////// Définition des types de base
|
||||
|
||||
typedef struct Composantes * Bitmap24B;
|
||||
typedef byte * Bitmap256;
|
||||
|
||||
|
||||
|
||||
//////////////////////////////////////// D‚finition d'une table de conversion
|
||||
//////////////////////////////////////// Définition d'une table de conversion
|
||||
|
||||
typedef struct
|
||||
{
|
||||
int nbb_r; // Nb de bits de pr‚cision sur les rouges
|
||||
int nbb_v; // Nb de bits de pr‚cision sur les verts
|
||||
int nbb_b; // Nb de bits de pr‚cision sur les bleu
|
||||
int nbb_r; // Nb de bits de précision sur les rouges
|
||||
int nbb_v; // Nb de bits de précision sur les verts
|
||||
int nbb_b; // Nb de bits de précision sur les bleu
|
||||
|
||||
int rng_r; // Nb de valeurs sur les rouges (= 1<<nbb_r)
|
||||
int rng_v; // Nb de valeurs sur les verts (= 1<<nbb_v)
|
||||
int rng_b; // Nb de valeurs sur les bleus (= 1<<nbb_b)
|
||||
|
||||
int dec_r; // Coefficient multiplicateur d'accŠs dans la table (= nbb_v+nbb_b)
|
||||
int dec_v; // Coefficient multiplicateur d'accŠs dans la table (= nbb_b)
|
||||
int dec_b; // Coefficient multiplicateur d'accŠs dans la table (= 0)
|
||||
int dec_r; // Coefficient multiplicateur d'accès dans la table (= nbb_v+nbb_b)
|
||||
int dec_v; // Coefficient multiplicateur d'accès dans la table (= nbb_b)
|
||||
int dec_b; // Coefficient multiplicateur d'accès dans la table (= 0)
|
||||
|
||||
int red_r; // Coefficient r‚ducteur de traduction d'une couleur rouge (= 8-nbb_r)
|
||||
int red_v; // Coefficient r‚ducteur de traduction d'une couleur verte (= 8-nbb_v)
|
||||
int red_b; // Coefficient r‚ducteur de traduction d'une couleur bleue (= 8-nbb_b)
|
||||
int red_r; // Coefficient réducteur de traduction d'une couleur rouge (= 8-nbb_r)
|
||||
int red_v; // Coefficient réducteur de traduction d'une couleur verte (= 8-nbb_v)
|
||||
int red_b; // Coefficient réducteur de traduction d'une couleur bleue (= 8-nbb_b)
|
||||
|
||||
byte * table;
|
||||
} Table_conversion;
|
||||
|
||||
|
||||
|
||||
///////////////////////////////////////// D‚finition d'une table d'occurences
|
||||
///////////////////////////////////////// Définition d'une table d'occurences
|
||||
|
||||
typedef struct
|
||||
{
|
||||
int nbb_r; // Nb de bits de pr‚cision sur les rouges
|
||||
int nbb_v; // Nb de bits de pr‚cision sur les verts
|
||||
int nbb_b; // Nb de bits de pr‚cision sur les bleu
|
||||
int nbb_r; // Nb de bits de précision sur les rouges
|
||||
int nbb_v; // Nb de bits de précision sur les verts
|
||||
int nbb_b; // Nb de bits de précision sur les bleu
|
||||
|
||||
int rng_r; // Nb de valeurs sur les rouges (= 1<<nbb_r)
|
||||
int rng_v; // Nb de valeurs sur les verts (= 1<<nbb_v)
|
||||
int rng_b; // Nb de valeurs sur les bleus (= 1<<nbb_b)
|
||||
|
||||
int dec_r; // Coefficient multiplicateur d'accŠs dans la table (= nbb_v+nbb_b)
|
||||
int dec_v; // Coefficient multiplicateur d'accŠs dans la table (= nbb_b)
|
||||
int dec_b; // Coefficient multiplicateur d'accŠs dans la table (= 0)
|
||||
int dec_r; // Coefficient multiplicateur d'accès dans la table (= nbb_v+nbb_b)
|
||||
int dec_v; // Coefficient multiplicateur d'accès dans la table (= nbb_b)
|
||||
int dec_b; // Coefficient multiplicateur d'accès dans la table (= 0)
|
||||
|
||||
int red_r; // Coefficient r‚ducteur de traduction d'une couleur rouge (= 8-nbb_r)
|
||||
int red_v; // Coefficient r‚ducteur de traduction d'une couleur verte (= 8-nbb_v)
|
||||
int red_b; // Coefficient r‚ducteur de traduction d'une couleur bleue (= 8-nbb_b)
|
||||
int red_r; // Coefficient réducteur de traduction d'une couleur rouge (= 8-nbb_r)
|
||||
int red_v; // Coefficient réducteur de traduction d'une couleur verte (= 8-nbb_v)
|
||||
int red_b; // Coefficient réducteur de traduction d'une couleur bleue (= 8-nbb_b)
|
||||
|
||||
int * table;
|
||||
} Table_occurence;
|
||||
|
||||
|
||||
|
||||
///////////////////////////////////////// D‚finition d'un ensemble de couleur
|
||||
///////////////////////////////////////// Définition d'un ensemble de couleur
|
||||
|
||||
typedef struct
|
||||
{
|
||||
@ -77,14 +77,14 @@ typedef struct
|
||||
byte bmin,bmax;
|
||||
|
||||
byte plus_large; // Composante ayant la plus grande variation (0=Rouge,1=Vert,2=Bleu)
|
||||
byte r,v,b; // Couleur synth‚tisant l'ensemble
|
||||
byte r,v,b; // Couleur synthétisant l'ensemble
|
||||
byte h; // Chrominance
|
||||
byte l; // Luminosit‚
|
||||
byte l; // Luminosité
|
||||
} Cluster;
|
||||
|
||||
|
||||
|
||||
//////////////////////////////////////// D‚finition d'un ensemble de clusters
|
||||
//////////////////////////////////////// Définition d'un ensemble de clusters
|
||||
|
||||
typedef struct
|
||||
{
|
||||
@ -95,31 +95,31 @@ typedef struct
|
||||
|
||||
|
||||
|
||||
///////////////////////////////////////////////////// D‚finition d'un d‚grad‚
|
||||
///////////////////////////////////////////////////// Définition d'un dégradé
|
||||
|
||||
typedef struct
|
||||
{
|
||||
int nbcouleurs; // Nombre de couleurs dans le d‚grad‚
|
||||
float min; // Chrominance minimale du d‚grad‚
|
||||
float max; // Chrominance maximale du d‚grad‚
|
||||
float hue; // Chrominance moyenne du d‚grad‚
|
||||
int nbcouleurs; // Nombre de couleurs dans le dégradé
|
||||
float min; // Chrominance minimale du dégradé
|
||||
float max; // Chrominance maximale du dégradé
|
||||
float hue; // Chrominance moyenne du dégradé
|
||||
} Degrade;
|
||||
|
||||
|
||||
|
||||
///////////////////////////////////////// D‚finition d'un ensemble de d‚grad‚
|
||||
///////////////////////////////////////// Définition d'un ensemble de dégradé
|
||||
|
||||
typedef struct
|
||||
{
|
||||
int nb; // Nombre de d‚grad‚s dans l'ensemble
|
||||
int nbmax; // Nombre maximum de d‚grad‚s
|
||||
Degrade * degrades; // Les d‚grad‚s
|
||||
int nb; // Nombre de dégradés dans l'ensemble
|
||||
int nbmax; // Nombre maximum de dégradés
|
||||
Degrade * degrades; // Les dégradés
|
||||
} DegradeSet;
|
||||
|
||||
|
||||
|
||||
/////////////////////////////////////////////////////////////////////////////
|
||||
///////////////////////////// M‚thodes de gestion des tables de conversion //
|
||||
///////////////////////////// Méthodes de gestion des tables de conversion //
|
||||
/////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
Table_conversion * TC_New(int nbb_r,int nbb_v,int nbb_b);
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user