garbage collecting again

.gitignore

@@ -2,6 +2,7 @@
 *.o
 
 libtthimage.a
+cscope.out
 
 Lib/foo
 Lib/testtga
@@ -9,8 +10,10 @@ Lib/t_png
 Lib/t_t16x24
 Lib/testbmp
 
-Tools/genplot2
+Tests/*.tga
+Tests/t_t16x24
 
+Tools/genplot2
 Tools/tga_alpha
 Tools/tga_cadre
 Tools/tga_combine

Lib/Makefile

@@ -16,9 +16,11 @@ all:	foo testtga
 
 alpha.o:	alpha.c		$(DEPS)
 alpha2.o:	alpha2.c	$(DEPS)
+anamorphose.o:	anamorphose.c	$(DEPS)
 
 basic_io.o:	basic_io.c	$(DEPS)
 bitblt.o:	bitblt.c	$(DEPS)
+bitplanes.o:	bitplanes.c	$(DEPS)
 bmp.o:		bmp.c		$(DEPS)		bmp.h
 
 cadres.o:	cadres.c	$(DEPS)
@@ -89,6 +91,7 @@ patterns2.o:	patterns2.c	$(DEPS)
 patterns3.o:	patterns3.c	$(DEPS)
 patterns4.o:	patterns4.c	$(DEPS)
 photomaton.o:	photomaton.c	$(DEPS)
+pcx.o:		pcx.c		$(DEPS)
 pht.o:		pht.c		$(DEPS)
 pixeliz.o:	pixeliz.c	$(DEPS)
 pixels.o:	pixels.c	$(DEPS)
@@ -104,6 +107,8 @@ pov_hf15f.o:	pov_hf15f.c	$(DEPS)
 pov_synth.o:	pov_synth.c	$(DEPS)
 ptlist.o:	ptlist.c	$(DEPS)
 
+quadpics.o:	quadpics.c	$(DEPS)
+
 recurse.o:	recurse.c	$(DEPS)
 rgbmask.o:	rgbmask.c	$(DEPS)
 
@@ -119,6 +124,7 @@ text1.o:	text1.c		$(DEPS)
 text16x24.o:	text16x24.c	$(DEPS)
 tga.o:		tga.c		$(DEPS)
 tools.o:	tools.c		$(DEPS)
+turtle.o:	turtle.c	$(DEPS)
 
 vignetize.o:	vignetize.c	$(DEPS)
 
@@ -132,11 +138,11 @@ zoom.o:		zoom.c		$(DEPS)
 #-----------------------------------------------------------------
 
 OBJECTS =	7seg.o							\
-		alpha.o alpha2.o					\
+		alpha.o alpha2.o anamorphose.o				\
-		basic_io.o bitblt.o bmp.o				\
+		basic_io.o bitblt.o bitplanes.o bmp.o			\
 		cadres2.o cadres3.o cadres4.o cadres84.o cadresbox.o	\
 		cadres.o						\
-		calculs.o classif.o 					\
+		calcluts.o calculs.o classif.o 				\
 		col4bits.o colors.o colors2.o col_reduc.o col_xyz.o	\
 		combine.o combine2.o combine3.o combine4.o combine5.o 	\
 		combine6.o combine_rnd.o				\
@@ -155,22 +161,24 @@ OBJECTS =	7seg.o							\
 		operat.o op2x2.o					\
 		palettes.o						\
 		patterns.o patterns2.o patterns3.o patterns4.o		\
+		pcx.o							\
 		photomaton.o pht.o pixeliz.o pixels.o plotteur.o	\
 		pnm.o png.o						\
 		pov_hf15a.o pov_hf15b.o pov_hf15c.o pov_hf15d.o 	\
 		pov_hf15e.o pov_hf15e.o pov_hf15f.o pov_synth.o		\
 		ptlist.o						\
+		quadpics.o						\
 		recurse.o rgbmask.o					\
 		scale.o	sobel4.o stereo.o				\
 		tamppool.o tele_2.o television.o			\
 		text0.o text1.o text16x24.o				\
-		tga.o tools.o						\
+		tga.o tools.o turtle.o					\
 		vignetize.o						\
 		warp0.o warp1.o warp2.o warp3.o				\
 		zoom.o
 
 ../libtthimage.a: 	$(OBJECTS)
-	$(AR) 	vrs $@ $?
+	$(AR) 	rs $@ $?
 	$(RANLIB)   $@
 
 #-----------------------------------------------------------------
@@ -178,16 +186,12 @@ OBJECTS =	7seg.o							\
 foo:		foo.c $(DEPS) ../libtthimage.a
 	gcc $(CFLAGS) $< ../libtthimage.a -o $@
 
-t_t16x24:	t_t16x24.c $(DEPS)  ../libtthimage.a
-	gcc $(CFLAGS) $< ../libtthimage.a -o $@
-
 t_png:	t_png.c $(DEPS)  ../libtthimage.a
 	gcc $(CFLAGS) $< ../libtthimage.a -lpng -lz -o $@
 
 testbmp:	testbmp.c $(DEPS)  ../libtthimage.a
 	gcc $(CFLAGS) $< ../libtthimage.a -lm -o $@
 
-
 #-----------------------------------------------------------------
 
 essais.o:	essais.c	$(DEPS) essais.h

Lib/anamorphose.c

@@ -7,7 +7,7 @@
 #include   <stdlib.h>
 #include   <math.h>
 
-#include   "tthimage.h"
+#include   "../tthimage.h"
 
 /*::------------------------------------------------------------------::*/
 int
@@ -16,16 +16,14 @@ Image_anmo_X(Image_Desc *src, Image_Desc *dst)
 int		x, y;
 double		dnormx, dnormy;
 
-fprintf(stderr, "%s : %p -> %p\n", __func__, src, dst);
+fprintf(stderr, ">>> %s: %p -> %p\n", __func__, src, dst);
 
 /*
  * we scan the destination picture
  */
-for (y=0; y<dst->height; y++)
+for (y=0; y<dst->height; y++) {
-	{
 	dnormy = (double)y/(double)dst->height;
-	for (x=0; x<dst->width; x++)
+	for (x=0; x<dst->width; x++) {
-		{
 		dnormx = (double)x/(double)dst->width;
 
 
@@ -73,10 +71,8 @@ double		xamp, yamp;
 long		nb_in, nb_out;
 #endif
 
-image = Image_alloc(w, h, 3);
+if (NULL==(image = Image_alloc(w, h, 3))) {
-if (image==NULL)
+	fprintf(stderr, "%s %s : Abend: no mem\n", __FILE__, __func__);
-	{
-	fprintf(stderr, "%s: Abend: no mem\n", __FILE__);
 	exit(5);
 	}
 

Lib/bitplanes.c

@@ -12,7 +12,7 @@
 
 #include  "../tthimage.h"
 
-#define VERSION_STRING "5 octobre 2015"
+#define VERSION_STRING "7 juiller 2022"
 
 /*::------------------------------------------------------------------::*/
 /*:: private variables */
@@ -45,7 +45,7 @@ int		taille;
 uint8_t		*pbits;
 
 #if DEBUG_LEVEL
-fprintf(stderr, "%s ( %d %d )\n", __func__, w, h);
+fprintf(stderr, ">>> %s ( %d %d )\n", __func__, w, h);
 #endif
 
 /* is there a sanity check on the dimensions ? */
@@ -90,7 +90,7 @@ int Image_free_that_BP(A_BitPlane *bp, int k)
 {
 
 #if DEBUG_LEVEL
-fprintf(stderr, "%s ( %p %d )\n", __func__, bp, k);
+fprintf(stderr, ">>> %s ( %p %d )\n", __func__, bp, k);
 #endif
 
 if (bp->magic != MAGIC_BIT_PLANE) {
@@ -117,7 +117,7 @@ return FUNC_IS_ALPHA;
 int Image_BP_setname(A_BitPlane *bp, const char *name)
 {
 #if DEBUG_LEVEL
-fprintf(stderr, "%s ( %p '%s' )\n", __func__, bp, name);
+fprintf(stderr, ">>> %s ( %p '%s' )\n", __func__, bp, name);
 #endif
 
 if (MAGIC_BIT_PLANE != bp->magic) {
@@ -186,10 +186,9 @@ offbit = x % 8;
 fprintf(stderr, "   offbyte %d, offbit %d\n", offbyte, offbit);
 fprintf(stderr, "   avant 0x%02x\n", bp->plane[offbyte]);
 #endif
-if (bit)
+
-	bp->plane[offbyte] |= (1 << offbit);
+if (bit)		bp->plane[offbyte] |= (1 << offbit);
-else
+else			bp->plane[offbyte] &= ~(1 << offbit);
-	bp->plane[offbyte] &= ~(1 << offbit);
 
 #if DEBUG_LEVEL > 1
 fprintf(stderr, "   apres 0x%02x\n", bp->plane[offbyte]);
@@ -243,7 +242,7 @@ fprintf(stderr, "%s ( %p '%s' 0x%03x )\n", __func__, bp, fname, k);
 
 if (NULL==(fp=fopen(fname, "w")))
 	{
-	fprintf(stderr, "fucked in %s\n", __func__);
+	fprintf(stderr, "fucked in %s on file '%s'\n", __func__, fname);
 	return FULL_NUCKED;
 	}
 
@@ -252,17 +251,14 @@ fprintf(fp, "# written by libtthimage v %s\n# bitplane module '%s'\n",
 			IMAGE_VERSION_STRING, VERSION_STRING);	
 
 chariot = 0;
-for (y=0; y<bp->height; y++)
+for (y=0; y<bp->height; y++) {
-	{
+	for (x=0; x<bp->width; x++) {
-	for (x=0; x<bp->width; x++)
-		{
 		Image_BP_pget(bp, x, y, &v);
 		if (v)		fputc('1', fp);
 		else		fputc('0', fp);
 		if (chariot++ < 74)
 			fputc(' ', fp);
-		else
+		else	{
-			{
 			fputc('\n', fp);	chariot=0;
 			}
 		}

Lib/calcluts.c

@@ -14,7 +14,7 @@
 #include  <alloca.h> 
 #endif
 
-#include  "tthimage.h"
+#include  "../tthimage.h"
 
 /*::------------------------------------------------------------------::*/
 int

Lib/combine.c

@@ -244,6 +244,9 @@ for (y=0; y<s1->height; y++)
 		b2 = (s2->Bpix[y])[x];
 
 		coef = (fx2+fy2)/dmax;
+		if (1==yo) {
+			coef = cos(coef);
+			}
 
 		if (coef < 0.0)		coef = 0.0;
 		if (coef > 1.0)		coef = 1.0;
@@ -253,6 +256,7 @@ for (y=0; y<s1->height; y++)
 		(d->Bpix[y])[x] = (int)(b1*(1.0-coef)+b2*coef);
 
 		}
+	fprintf(stderr, "x %4d y %4d c %f\n", x, y, coef);
 	}
 
 return OLL_KORRECT;

Lib/combine5.c

@@ -21,20 +21,17 @@ int	r2, g2, b2;
 int	rd, gd, bd;
 double	k, ka, kb;
 
-if ( (foo=Image_compare_desc(s1, s2)) )
+if ( (foo=Image_compare_desc(s1, s2)) ) {
-	{
+	fprintf(stderr, "%s: sources err: %s\n", __func__, Image_err2str(foo));
-	fprintf(stderr, "V degrade: sources err: %s\n", Image_err2str(foo));
 	return foo;
 	}
 
-for (y=0; y<s1->height; y++)
+for (y=0; y<s1->height; y++) {
-	{
 	k = (double)y/(double)s1->height;
 	if (sens)	{ ka = k;	kb = 1.0 - ka; }
 	else		{ kb = k;	ka = 1.0 - kb; }
 
-	for (x=0; x<s1->width; x++)
+	for (x=0; x<s1->width; x++) {
-		{
 		Image_getRGB(s1, x, y, &r1, &g1, &b1);
 		Image_getRGB(s2, x, y, &r2, &g2, &b2);
 		rd = (int)((double)r1*ka+(double)r2*(kb));
@@ -57,19 +54,16 @@ int	r2, g2, b2;
 int	rd, gd, bd;
 double	k, ka, kb;
 
-if ( (foo=Image_compare_desc(s1, s2)) )
+if ( (foo=Image_compare_desc(s1, s2)) ) {
-	{
+	fprintf(stderr, "%s: sources err: %s\n", __func__, Image_err2str(foo));
-	fprintf(stderr, "H degrade: sources err: %s\n", Image_err2str(foo));
 	return foo;
 	}
 
-for (x=0; x<s1->width; x++)
+for (x=0; x<s1->width; x++) {
-	{
 	k = (double)x/(double)s1->width;
 	if (sens)	{ ka = k;	kb = 1.0-ka; }
 	else		{ kb = k;	ka = 1.0-kb; }
-	for (y=0; y<s1->height; y++)
+	for (y=0; y<s1->height; y++) {
-		{
 		Image_getRGB(s1, x, y, &r1, &g1, &b1);
 		Image_getRGB(s2, x, y, &r2, &g2, &b2);
 		rd = (int)((double)r1*ka+(double)r2*(kb));
@@ -96,14 +90,12 @@ int		foo;
 fprintf(stderr, "%s:%d:%s: no such function or procedure\n",
 		__FILE__, __LINE__, __func__);
 
-if ( (foo=Image_compare_desc(s1, s2)) )
+if ( (foo=Image_compare_desc(s1, s2)) ) {
-	{
+	fprintf(stderr, "%s: sources err: %s\n", __func__, Image_err2str(foo));
-	fprintf(stderr, "D degrade: sources err: %s\n", Image_err2str(foo));
 	return foo;
 	}
-if ( (foo=Image_compare_desc(s1, dst)) )
+if ( (foo=Image_compare_desc(s1, dst)) ) {
-	{
+	fprintf(stderr, "%s: dst err: %s\n", __func__, Image_err2str(foo));
-	fprintf(stderr, "D degrade: dst err: %s\n", Image_err2str(foo));
 	return foo;
 	}
 
@@ -120,30 +112,25 @@ int Image_combine_Vsplit(Image_Desc *s1, Image_Desc *s2, Image_Desc *d,
 int		foo, x, y;
 
 #if DEBUG_LEVEL
-fprintf(stderr, "%s ( %p %p %p %d %d )\n", __func__, s1, s2, d, xv, uh);
+fprintf(stderr, ">>> %s ( %p %p %p %d %d )\n", __func__, s1, s2, d, xv, uh);
 #endif
 
 if (0 != uh)
 	fprintf(stderr, "%s : uh must be 0 and not %d\n", __func__, uh);
 
-if ( (foo=Image_compare_desc(s1, s2)) )
+if ( (foo=Image_compare_desc(s1, s2)) ) {
-	{
 	fprintf(stderr, "%s : src err: %s\n", __func__, Image_err2str(foo));
 	return foo;
 	}
 
-for (y=0; y<s1->height; y++)
+for (y=0; y<s1->height; y++) {
-	{
+	for (x=0; x<s1->width; x++) {
-	for (x=0; x<s1->width; x++)
+		if (x<xv) {
-		{
-		if (x<xv)
-			{
 			(d->Rpix[y])[x] = (s1->Rpix[y])[x];
 			(d->Gpix[y])[x] = (s1->Gpix[y])[x];
 			(d->Bpix[y])[x] = (s1->Bpix[y])[x];
 			}
-		else
+		else {
-			{
 			(d->Rpix[y])[x] = (s2->Rpix[y])[x];
 			(d->Gpix[y])[x] = (s2->Gpix[y])[x];
 			(d->Bpix[y])[x] = (s2->Bpix[y])[x];
@@ -163,7 +150,7 @@ int Image_combine_Hsplit(Image_Desc *s1, Image_Desc *s2, Image_Desc *d,
 int		x, y;
 
 #if DEBUG_LEVEL
-fprintf(stderr, "%s (%p %p %p %d %d)\n", __func__, s1, s2, d, yv, uh);
+fprintf(stderr, ">>> %s ( %p %p %p %d %d )\n", __func__, s1, s2, d, yv, uh);
 #endif
 
 if (0 != uh)

Lib/contours.c

@@ -4,7 +4,7 @@
 
 #include  <stdio.h>
 
-#include  "tthimage.h"
+#include  "../tthimage.h"
 
 /*::------------------------------------------------------------------::*/
 /*

Lib/detect2.c

@@ -4,7 +4,7 @@
 */
 
 #include  <stdio.h>
-#include  "tthimage.h"
+#include  "../tthimage.h"
 
 /*::------------------------------------------------------------------::*/
 /*
@@ -17,6 +17,10 @@ int		foo, val;
 int		x, y;
 long		nbre;
 
+#if DEBUG_LEVEL
+fprintf(stderr, ">>> %s ( %p %d %p )\n", __func__, img, seuilr, ptl);
+#endif
+
 nbre = 0;
 for (y=0; y<img->height; y++)
 	{

Lib/effects.c

@@ -100,22 +100,18 @@ Image_noise(Image_Desc *source, Image_Desc *but, int intensite)
 {
 int     x, y, r, g, b, foo;
 
-if ( (foo=Image_compare_desc(source, but)) )
+if ( (foo=Image_compare_desc(source, but)) ) {
-    {
 	fprintf(stderr, "%s : images are differents %d\n", __func__,  foo);
 	return foo;
 	}
 
-if (intensite < 1)
+if (intensite < 1) {
-    {
 	fprintf(stderr, "%s : bad intensity %d\n", __func__, intensite);
 	intensite = 1;
 	}
 
-for (x=0; x<source->width; x++)
+for (x=0; x<source->width; x++) {
-    {
+    for (y=0; y<source->height; y++) {
-    for (y=0; y<source->height; y++)
-        {
         r = Image_clamp_pixel((source->Rpix[y])[x]
                               + (rand()%intensite) - (intensite/2));
         g = Image_clamp_pixel((source->Gpix[y])[x]

Lib/gray_ops.c

@@ -5,7 +5,7 @@
 #include  <stdio.h>
 #include  <stdlib.h>
 
-#include  "tthimage.h"
+#include  "../tthimage.h"
 
 /*::------------------------------------------------------------------::*/
 int Image_gray_ops_0(Image_Desc *src, Image_Desc *dst, int k, int mask)

Lib/imprime.c

@@ -7,15 +7,13 @@
 #include  "../tthimage.h"
 
 /*::------------------------------------------------------------------::*/
-int
+int Image_print_histo_0(long *histo, char *fname, char *texte)
-Image_print_histo_0(long *histo, char *fname, char *texte)
 {
 int	foo;
 
-printf("** %s **\n", texte);
+printf("** %s / %s **\n", texte, fname);
 
-for (foo=0; foo<256; foo++)
+for (foo=0; foo<256; foo++) {
-	{
 	printf("%7ld ", histo[foo]);
 	if ((foo % 8)==0)
 		printf("\n");
@@ -36,8 +34,7 @@ unsigned long		grand;
 unsigned char		*ucptr;
 int			foo;
 
-if (NULL != texte)
+if (NULL != texte) {
-	{
 	printf("============= %s ============\n", texte);
 	}
 
@@ -57,16 +54,16 @@ for (foo=0; foo<sizeof(grand); foo++)
 printf("\n");
 
 /* examen des types de base */
-printf("basic types : short=%d int=%d long=%d ptr=%d\n",
+printf("basic types    : short=%ld int=%ld long=%ld ptr=%ld\n",
 		sizeof(short), sizeof(int), sizeof(long), sizeof(void *));
 
 /* examen des tructures de la libtthimage */
-printf("Image_Desc     :  %5u\n", sizeof(Image_Desc)); 
+printf("Image_Desc     :  %5ld\n", sizeof(Image_Desc)); 
-printf("Image_Rect     :  %5u\n", sizeof(Image_Rect)); 
+printf("Image_Rect     :  %5ld\n", sizeof(Image_Rect)); 
-printf("RGBA           :  %5u\n", sizeof(RGBA)); 
+printf("RGBA           :  %5ld\n", sizeof(RGBA)); 
-printf("A_BitPlane     :  %5u\n", sizeof(A_BitPlane)); 
+printf("A_BitPlane     :  %5ld\n", sizeof(A_BitPlane)); 
-printf("RGB_map        :  %5u\n", sizeof(RGB_map)); 
+printf("RGB_map        :  %5ld\n", sizeof(RGB_map)); 
-printf("Image_Point    :  %5u\n", sizeof(Image_Point)); 
+printf("Image_Point    :  %5ld\n", sizeof(Image_Point)); 
 
 }
 /*::------------------------------------------------------------------::*/

Lib/mircol.c

@@ -10,8 +10,7 @@
 #include   "../tthimage.h"
 
 /*::------------------------------------------------------------------::*/
-int
+int Image_mircol_0(Image_Desc *dst, char *txt, int flag)
-Image_mircol_0(Image_Desc *dst, char *txt, int flag)
 {
 int	x, y;
 RGBA	fond, encre;
@@ -66,8 +65,7 @@ return FUNC_IS_BETA;
 }
 /*::------------------------------------------------------------------::*/
 /* a quoi sert ce flag */
-int
+int Image_mircol_1(Image_Desc *dst, char *txt, int flag)
-Image_mircol_1(Image_Desc *dst, char *txt, int flag)
 {
 RGBA	fond, encre;
 int	x, y, r, g, b;
@@ -239,19 +237,20 @@ int Image_mirRGB_0(Image_Desc *dst, int flag)
 int	x, y;
 
 #if DEBUG_LEVEL
-fprintf(stderr, "%s : %p %d\n", __func__, dst, flag);
+fprintf(stderr, ">>> %s ( %p %d )\n", __func__, dst, flag);
 #endif
 
-if (dst->width != 256 || dst->height != 256)
+if (flag) {
-	{
+	fprintf(stderr, "flag is %d in %s\n", flag, __func__);
+	}
+
+if (dst->width != 256 || dst->height != 256) {
 	fprintf(stderr, "Image mire RGB 0: image is not 256x256\n");
 	return IMAGE_BAD_DIMS;
 	}
 
-for (x=0; x<256; x++)
+for (x=0; x<256; x++) {
-	{
+	for (y=0; y<256; y++) {
-	for (y=0; y<256; y++)
-		{
 		(dst->Rpix[y])[x] = x;
 		(dst->Gpix[y])[x] = y;
 		(dst->Bpix[y])[x] = (y+x)/2;

Lib/octree.c

@@ -11,7 +11,7 @@
 
 #include  <stdio.h>
 
-#include  "tthimage.h"
+#include  "../tthimage.h"
 
 /*::------------------------------------------------------------------::*/
 /*
@@ -22,7 +22,7 @@ Image_octree_0(Image_Desc *src, Image_Desc *dst)
 {
 
 #if DEBUG
-fprintf(stderr, "%s ( %p %p )\n", __func__, src, dst);
+fprintf(stderr, ">>> %s ( %p %p )\n", __func__, src, dst);
 #endif
 
 return FULL_NUCKED;
@@ -33,7 +33,7 @@ Image_octree_1(Image_Desc *src, Image_Desc *dst)
 {
 
 #if DEBUG
-fprintf(stderr, "%s ( %p %p )\n", __func__, src, dst);
+fprintf(stderr, ">>> %s ( %p %p )\n", __func__, src, dst);
 #endif
 
 return FULL_NUCKED;

Lib/palettes.c

@@ -411,6 +411,9 @@ if ( (fp=fopen(fname, "w")) == NULL )
 	return FILE_CREATE_ERR;
 	}
 fprintf(fp, "P3\n%d 1\n255\n", p->nbre);
+if (NULL != comment) {
+	fprintf(fp, "# %s\n", comment);
+	}
 for (foo=0; foo<p->nbre; foo++)
 	{
 	fprintf(fp, "%3d %3d %3d\n", p->red[foo], p->green[foo], p->blue[foo]);

Lib/patterns3.c

@@ -99,7 +99,7 @@ for (x=0; x<dst->width; x++)
 	for (y=0; y<dst->height; y++)
 		{
 		dy = (double)x / (double)dst->height;
-		r = (int)round(256.0 * sqrt(dx * dy));
+		r = (int)round(256.0 * sqrt(dx * dy));		/* XXX */
 		g = b = rand() & 0xf0;
 		Image_plotRGB(dst, x, y, r, g, b);
 		}

Lib/pixeliz.c

@@ -58,10 +58,14 @@ Image_pixeliz_X(Image_Desc *src, Image_Desc *dst)
 {
 int foo;
 
+#if DEBUG_LEVEL
 fprintf(stderr, "Pixeliz X: appel de test, pas finalise.\n");
+#endif
 
 foo = Image_pixeliz_0(src, dst, 5, 13);
+#if DEBUG_LEVEL
 fprintf(stderr, "Pixeliz X: valeur obtenue: %d\n", foo);
+#endif
 
 return foo;
 }

Lib/pixels.c

@@ -9,7 +9,7 @@
 int
 Image_XOR_pixel(Image_Desc *img, int x, int y, int r, int g, int b)
 {
-int	pr, pg, pb, a;
+int	pr, pg, pb;
 
 if ( (x<0) || (y<0) || (x>=img->width) || (y>=img->height) )
 	{

Lib/png.c

@@ -42,7 +42,7 @@ fprintf(stderr, "%s ( '%s' %d )\n", __func__, fname, k);
 writepng_version_info();
 #endif
 
-return 666;
+return NULL;
 }
 /*::------------------------------------------------------------------::*/
 int Image_save_as_PNG(Image_Desc *img, char *fname, int p1, int p2)

Lib/pov_hf15c.c

@@ -19,30 +19,25 @@
  *
  *     Le coefficient K va de 0 a 10000 !
  */
-int
+int Image_hf15_mix(Image_Desc *s1, Image_Desc *s2, Image_Desc *dst, int k)
-Image_hf15_mix(Image_Desc *s1, Image_Desc *s2, Image_Desc *dst, int k)
 {
 int	foo, x, y, h1, h2, hd;
 
 #if DEBUG_LEVEL
-fprintf(stderr, "%s: k = %d\n", __func__, k);
+fprintf(stderr, ">>> %s: k = %d\n", __func__, k);
 #endif
 
-if ( (foo=Image_compare_desc(s1, s2)) )
+if ( (foo=Image_compare_desc(s1, s2)) ) {
-	{
 	fprintf(stderr, "hf15 mix: err on sources: %s\n", Image_err2str(foo));
 	return foo;
 	}
-if ( (foo=Image_compare_desc(s1, dst)) )
+if ( (foo=Image_compare_desc(s1, dst)) ) {
-	{
 	fprintf(stderr, "hf15 mix: err on dest: %s\n", Image_err2str(foo));
 	return foo;
 	}
 
-for (y=0; y<s1->height; y++)
+for (y=0; y<s1->height; y++) {
-	{
+	for (x=0; x<s1->width; x++) {
-	for (x=0; x<s1->width; x++)
-		{
 		h1 = Image_hf15_height(s1, x, y);
 		h2 = Image_hf15_height(s2, x, y);
 		hd = ((h1*k) + (h2*(10000-k))) / 10000;
@@ -63,26 +58,21 @@ return FUNC_IS_BETA;
  *  new 5 Janvier 2003
  *	il y a probablement des problemes d'overflow ici.
  */
-int
+int Image_hf15_mult_i(Image_Desc *s1, Image_Desc *s2, Image_Desc *dst)
-Image_hf15_mult_i(Image_Desc *s1, Image_Desc *s2, Image_Desc *dst)
 {
 int	foo, x, y, h1, h2, hd;
 
-if ( (foo=Image_compare_desc(s1, s2)) )
+if ( (foo=Image_compare_desc(s1, s2)) ) {
-	{
 	fprintf(stderr, "hf15 mult i: err on srces: %s\n", Image_err2str(foo));
 	return foo;
 	}
-if ( (foo=Image_compare_desc(s1, dst)) )
+if ( (foo=Image_compare_desc(s1, dst)) ) {
-	{
 	fprintf(stderr, "hf15 mult: err on dest: %s\n", Image_err2str(foo));
 	return foo;
 	}
 
-for (y=0; y<s1->height; y++)
+for (y=0; y<s1->height; y++) {
-	{
+	for (x=0; x<s1->width; x++) {
-	for (x=0; x<s1->width; x++)
-		{
 		h1 = Image_hf15_height(s1, x, y);
 		h2 = Image_hf15_height(s2, x, y);
 		hd = (h1 * h2) / 32768;
@@ -96,21 +86,17 @@ return FUNC_IS_BETA;
 }
 /*::------------------------------------------------------------------::*/
 /* nouveau 17 novembre 2009 - avenue St Exupery */
-int 
+int Image_hf15_mult_k(Image_Desc *s, Image_Desc *d, float dk)
-Image_hf15_mult_k(Image_Desc *s, Image_Desc *d, float dk)
 {
 int	foo, x, y, h1, h2;
 
-if ( (foo=Image_compare_desc(s, d)) )
+if ( (foo=Image_compare_desc(s, d)) ) {
-	{
 	fprintf(stderr, "hf15 mult k: error: %s\n", Image_err2str(foo));
 	return foo;
 	}
 
-for (y=0; y<s->height; y++)
+for (y=0; y<s->height; y++) {
-	{
+	for (x=0; x<s->width; x++) {
-	for (x=0; x<s->width; x++)
-		{
 		h1 = Image_hf15_height(s, x, y);
 		h2 = (int)( (float)h1 * dk );
 		Image_hf15_plot(d, x, y, h2);
@@ -121,12 +107,11 @@ return FULL_NUCKED;
 }
 /*::------------------------------------------------------------------::*/
 /* nouveau Juin 2008 - avenue St Exupery */
-int
+int Image_hf15_div_i(Image_Desc *s1, Image_Desc *s2, Image_Desc *dst)
-Image_hf15_div_i(Image_Desc *s1, Image_Desc *s2, Image_Desc *dst)
 {
 
 #if DEBUG_LEVEL
-fprintf(stderr, "%s ( %p %p %p )\n", __func__, s1, s2, dst);
+fprintf(stderr, ">>> %s ( %p %p %p )\n", __func__, s1, s2, dst);
 #endif
 
 return FULL_NUCKED;
@@ -141,24 +126,20 @@ int		foo;
 float		rh, mean_a;
 
 #if DEBUG_LEVEL
-fprintf(stderr, "%s ( %p , %p )\n", __func__, src, dst);
+fprintf(stderr, ">>> %s ( %p , %p )\n", __func__, src, dst);
 #endif
 
-if ( (foo=Image_compare_desc(src, dst)) )
+if ( (foo=Image_compare_desc(src, dst)) ) {
-	{
 	fprintf(stderr, "hf15 sqrt: (failed) : %s\n", Image_err2str(foo));
 	return foo;
 	}
 
 mean_a = 0.0;
 
-for (y=0; y<src->height; y++)
+for (y=0; y<src->height; y++) {
-	{
+	for (x=0; x<src->width; x++) {
-	for (x=0; x<src->width; x++)
-		{
 		h = Image_hf15_height(src, x, y);
-		if (h < 0)
+		if (h < 0) {
-			{
 			fprintf(stderr, "WTF ! %s  %p  %d,%d   %d\n",
 						__func__,
 						src, x, y, h);
@@ -178,8 +159,7 @@ return FUNC_IS_BETA;
 }
 /*::------------------------------------------------------------------::*/
 /* nouveau Novembre 2008 - avenue St Exupery */
-int
+int Image_hf15_pow(Image_Desc *src, Image_Desc *dst, double p0w44)
-Image_hf15_pow(Image_Desc *src, Image_Desc *dst, double p0w44)
 {
 int		x, y, h;
 int		foo;
@@ -188,20 +168,18 @@ float		rh;
 float		minh, maxh;
 
 #if DEBUG_LEVEL
-fprintf(stderr, "%s ( %p , %p, %g )\n", __func__, src, dst, p0w44);
+fprintf(stderr, ">>> %s ( %p , %p, %g )\n", __func__, src, dst, p0w44);
 #endif
 
-if ( (foo=Image_compare_desc(src, dst)) )
+if ( (foo=Image_compare_desc(src, dst)) ) {
-	{
 	fprintf(stderr, "%s : (fail) : %s\n", __func__, Image_err2str(foo));
 	return foo;
 	}
-minh =  999999.99;
+
-maxh = -999999.99;
+minh =  9999999.99;
-for (y=0; y<src->height; y++)
+maxh = -9999999.99;
-	{
+for (y=0; y<src->height; y++) {
-	for (x=0; x<src->width; x++)
+	for (x=0; x<src->width; x++) {
-		{
 		h = Image_hf15_height(src, x, y);
 		rh = (float)h / 32768.0;
 		rh = pow(rh, p0w44);
@@ -226,19 +204,16 @@ int		foo, x, y, h;
 double		rh;
 
 #if DEBUG_LEVEL
-fprintf(stderr, "%s ( %p , %p )\n", __func__, src, dst);
+fprintf(stderr, ">>> %s ( %p , %p )\n", __func__, src, dst);
 #endif
 
-if ( (foo=Image_compare_desc(src, dst)) )
+if ( (foo=Image_compare_desc(src, dst)) ) {
-	{
 	fprintf(stderr, "%s : (fail) : %s\n", __func__, Image_err2str(foo));
 	return foo;
 	}
 
-for (y=0; y<src->height; y++)
+for (y=0; y<src->height; y++) {
-	{
+	for (x=0; x<src->width; x++) {
-	for (x=0; x<src->width; x++)
-		{
 		h = Image_hf15_height(src, x, y);
 		rh = (double)h / 32768.0;
 		rh = exp(rh) - 1.0;
@@ -254,7 +229,7 @@ return FUNC_IS_ALPHA;
 int Image_hf15_exp2(Image_Desc *src, Image_Desc *dst)
 {
 #if DEBUG_LEVEL
-fprintf(stderr, "%s ( %p , %p )\n", __func__, src, dst);
+fprintf(stderr, ">>> %s ( %p  %p )\n", __func__, src, dst);
 #endif
 return FULL_NUCKED;
 }

Lib/pov_hf15f.c

@@ -29,6 +29,10 @@ fprintf(stderr, "%s : img=%p   hfin=%d   taille=%d   k=%d\n",
 fprintf(stderr, "   pic dims : %d x %d\n", im->width, im->height);
 #endif
 
+if (taille) {
+	fprintf(stderr, "%s : taille = %d, wtf?\n", __func__, taille);
+	}
+
 /* this is really a MESS ! */
 fhfin = (float)(hfin*hfin);
 x2 = im->width / 2;

Lib/ptlist.c

@@ -12,15 +12,13 @@
 #include  "../tthimage.h"
 
 /*::------------------------------------------------------------------::*/
-int
+int Image_print_point(Image_Point *ppt)
-Image_print_point(Image_Point *ppt)
 {
 printf(" xy %-4d %-4d  c %-3d  h %d\n", ppt->x, ppt->y, ppt->c, ppt->h);
 return FUNC_IS_ALPHA;
 }
 /*::------------------------------------------------------------------::*/
-int
+int Image_ptl_dump(Image_PtList *pl, char *txt)
-Image_ptl_dump(Image_PtList *pl, char *txt)
 {
 fprintf(stderr, "---+---------------\n");
 fprintf(stderr, "   |  %s\n", txt);
@@ -32,8 +30,7 @@ fprintf(stderr, "---+---------------\n");
 return FUNC_IS_BETA;
 }
 /*::------------------------------------------------------------------::*/
-Image_PtList *
+Image_PtList * Image_ptl_alloc(int nbre, char *name)
-Image_ptl_alloc(int nbre, char *name)
 {
 Image_PtList *ptr;
 
@@ -71,8 +68,7 @@ if ( (ptr->points=malloc(sizeof(Image_Point)*nbre))==NULL)
 return ptr;
 }
 /*::------------------------------------------------------------------::*/
-int
+int Image_ptl_add(Image_PtList *ptl, int x, int y, int h, int c)
-Image_ptl_add(Image_PtList *ptl, int x, int y, int h, int c)
 {
 Image_Point *ptrpt;
 int newsize, idx;
@@ -124,8 +120,7 @@ return FUNC_IS_BETA;
  *	des programmes FORTRAN, beaucoup plus pointilleux sur le 
  *	formatage des données.
  */
-int
+int Image_ptl_write(char *filename, Image_PtList *ptl)
-Image_ptl_write(char *filename, Image_PtList *ptl)
 {
 FILE	*fp;
 int	foo;
@@ -151,19 +146,19 @@ fclose(fp);
 return FUNC_IS_BETA;
 }
 /*::------------------------------------------------------------------::*/
-int
+int Image_ptl_read(char *filename, Image_PtList *ptl)
-Image_ptl_read(char *filename, Image_PtList *ptl)
 {
 FILE	*fp;
 int	foo;
 
 #if DEBUG_LEVEL
-fprintf(stderr, "%s ( '%s' %p )\n", __func__, filename, ptl);
+fprintf(stderr, ">>> %s ( '%s' %p )\n", __func__, filename, ptl);
 #endif
 
 if (ptl->control != 0xfde9601a)
 	{
 	fprintf(stderr, "%s: no deadbeef in %p\n", __func__, ptl);
+	fprintf(stderr, "    can't read '%s'\n", filename);
 	return 666;
 	}
 
@@ -174,8 +169,7 @@ return FULL_NUCKED;
 }
 /*::------------------------------------------------------------------::*/
 /*		destruction d'une liste de points			*/
-int
+int Image_ptl_kill(Image_PtList *ptl, char *msg)
-Image_ptl_kill(Image_PtList *ptl, char *msg)
 {
 #if DEBUG_LEVEL
 fprintf(stderr, "Killing point list %p for '%s'\n", ptl, msg);
@@ -187,6 +181,10 @@ if (ptl->control != 0xfde9601a)
 	return 666;
 	}
 
+if (NULL != msg) {
+	fprintf(stderr, "%s is killing %p because %s\n", __func__, ptl, msg);
+	}
+
 /* killing the array */
 free(ptl->points);	ptl->points = NULL;
 ptl->control = 0;
@@ -211,8 +209,7 @@ if (NULL != alloc)		*alloc = ptl->alloc;
 return OLL_KORRECT;
 }
 /*::------------------------------------------------------------------::*/
-int 
+int Image_ptl_get_point(Image_PtList *ptl, Image_Point *pt, int idx)
-Image_ptl_get_point(Image_PtList *ptl, Image_Point *pt, int idx)
 {
 if (ptl->control != 0xfde9601a)
 	{
@@ -241,8 +238,7 @@ fprintf(stderr, "%s: %p %d -> %d %d\n", __func__, ptl, idx, pt->x, pt->y);
 return FUNC_IS_BETA;
 }
 /*::------------------------------------------------------------------::*/
-int
+int Image_ptl_boundingbox(Image_PtList *ptl, Image_Rect *box)
-Image_ptl_boundingbox(Image_PtList *ptl, Image_Rect *box)
 {
 int	xmin, ymin, xmax, ymax;
 int	foo;

Lib/quadpics.c

@@ -5,7 +5,7 @@
 #include  <stdio.h>
 #include  <stdlib.h>
 
-#include  "tthimage.h"
+#include  "../tthimage.h"
 
 /*::------------------------------------------------------------------::*/
 /*

Lib/scale.c

@@ -33,6 +33,11 @@ fprintf(stderr, "scale simple: %p (%dx%d) -> %p (%dx%d) k:%d \n",
 				dst, dst->width, dst->height, k);
 #endif
 
+if (k) {
+	fprintf(stderr, "in %s, k must be zero, was %d\n", __func__, k);
+	return BAD_PARAMETER;
+	}
+
 coefX = (float)dst->width / (float)src->width;
 coefY = (float)dst->height / (float)src->height;
 
@@ -65,8 +70,8 @@ return FUNC_IS_ALPHA;
 }
 /*::------------------------------------------------------------------::*/
 /* new 2 nov 2009 - ave StEx */
-/* I've lost all my mathematical concepts (la vieillesse est un naufrage)
+/* I've lost all my mathematical concepts so I'm going to make
- * so I'm going to make some approximations\dots */
+   some approximations\dots */
 
 static int getpix_bilin(Image_Desc *src, double fx, double fy, 
 					int *pr, int *pg, int *pb)
@@ -145,6 +150,11 @@ fprintf(stderr, "scale bilinear: %p (%dx%d) -> %p (%dx%d) k:%d \n",
 				dst, dst->width, dst->height, k);
 #endif
 
+if (k) {
+	fprintf(stderr, "in %s, k must be zero, was %d\n", __func__, k);
+	return BAD_PARAMETER;
+	}
+
 coefX = (double)dst->width / (double)src->width;
 coefY = (double)dst->height / (double)src->height;
 
@@ -152,12 +162,10 @@ coefY = (double)dst->height / (double)src->height;
 fprintf(stderr, "%s : coefs  %lf %lf\n", __func__, coefX, coefY);
 #endif
 
-for (yd=0; yd<dst->height; yd++)
+for (yd=0; yd<dst->height; yd++) {
-	{
 	fyd = (double)yd;
 	fys = fyd / coefY;
-	for (xd=0; xd<dst->width; xd++)
+	for (xd=0; xd<dst->width; xd++) {
-		{
 		fxd = (double)xd;
 		fxs = fxd / coefX;
 
@@ -199,6 +207,11 @@ fprintf(stderr, "image\t%d %d, scale %f %f\n",
 		src->width, src->height, scaleX, scaleY);
 #endif
 
+if (methode) {
+	fprintf(stderr, "in %s, methode must be zero, was %d\n", __func__, methode);
+	return NULL;
+	}
+
 fx = (float)src->width * scaleX;
 fy = (float)src->height * scaleY;
 
@@ -221,6 +234,9 @@ fprintf(stderr, "\tnew image @ %p\n", dst);
 #endif
 
 foo = Image_scale_simple(src, dst, 0);
+if (foo) {
+	fprintf(stderr, "in %s scale_simple -> %d\n", __func__, foo);
+	}
 
 return dst;
 }

Lib/sobel4.c

@@ -25,11 +25,9 @@ int		x, y, r, g, b;
 
 memcpy(filtre, Sobel, 11*sizeof(int));
 
-for (foo=0; foo<4; foo++)
+for (foo=0; foo<4; foo++) {
-	{
 	fprintf(stderr, "sobel4: pass %d\n", foo);
-	if (NULL == (tmp[foo] = Image_clone(src, 0)))
+	if (NULL == (tmp[foo] = Image_clone(src, 0))) {
-		{
 		fprintf(stderr,"Sobel 4: no memory, aborting\n");
 		abort();
 		}
@@ -38,10 +36,8 @@ for (foo=0; foo<4; foo++)
 	Image_rotate_filtre(filtre);
 	}
 
-for (x=0; x<src->width; x++)
+for (x=0; x<src->width; x++) {
-	{
+	for (y=0; y<src->height; y++) {
-	for (y=0; y<src->height; y++)
-		{
 		r = ( tmp[0]->Rpix[y][x] + tmp[1]->Rpix[y][x] +
 		      tmp[2]->Rpix[y][x] + tmp[3]->Rpix[y][x]) / 4;
 		g = ( tmp[0]->Gpix[y][x] + tmp[1]->Gpix[y][x] +
@@ -57,8 +53,7 @@ for (x=0; x<src->width; x++)
 
 dst->modified   = 1;
 
-for (foo=0; foo<4; foo++)
+for (foo=0; foo<4; foo++) {
-	{
 #if DEBUG_LEVEL > 1
 	fprintf(stderr, "%s: freeing %d\n", __func__, foo);
 #endif
@@ -68,6 +63,3 @@ for (foo=0; foo<4; foo++)
 return FUNC_NOT_FINISH;
 }
 /*::------------------------------------------------------------------::*/
-/*::------------------------------------------------------------------::*/
-/*::------------------------------------------------------------------::*/
-

Lib/stereo.c

@@ -20,20 +20,17 @@ Image_combine_stereo_0(Image_Desc *gauche, Image_Desc *droite,
 int		x, y, foo;
 int		rouge, vert;
 
-if ( (foo=Image_compare_desc(gauche, droite)) )
+if ( (foo=Image_compare_desc(gauche, droite)) ) {
-	{
 	fprintf(stderr, "Combine Stereo 0: sources are differents (%d)\n", foo);
 	return foo;
 	}
 
-if ( (foo=Image_compare_desc(gauche, stereo)) )
+if ( (foo=Image_compare_desc(gauche, stereo)) ) {
-	{
 	fprintf(stderr, "Combine Stereo 0: dest have a bad dim  (%d)\n", foo);
 	return foo;
 	}
 
-for (y=0; y<gauche->height; y++)
+for (y=0; y<gauche->height; y++) {
-	{
 	for (x=0; x<droite->width; x++)
 		{
 		rouge = ( Image_R_pixel(droite, x, y)+
@@ -67,13 +64,11 @@ Image_combine_stereo_1(Image_Desc *s1, Image_Desc *s2, Image_Desc *d,
 int		x, y, foo, cumul;
 int		rouge, bleu;
 
-if ( (foo=Image_compare_desc(s1, s2)) )
+if ( (foo=Image_compare_desc(s1, s2)) )	{
-	{
 	fprintf(stderr, "Combine Stereo 1: sources are differents (%d)\n", foo);
 	return foo;
 	}
-if ( (foo=Image_compare_desc(s1, d)) )
+if ( (foo=Image_compare_desc(s1, d)) ) {
-	{
 	fprintf(stderr, "Combine Stereo 1: dest have a bad dim  (%d)\n", foo);
 	return foo;
 	}
@@ -84,10 +79,8 @@ fprintf(stderr, "Combine Stereo 1: coefs are %d %d %d\n", kr, kg, kb);
 fprintf(stderr, "Combine Stereo 1: cumul is %d\n", cumul);
 #endif
 
-for (y=0; y<s1->height; y++)
+for (y=0; y<s1->height; y++) {
-	{
+	for (x=0; x<s1->width; x++) {
-	for (x=0; x<s1->width; x++)
-		{
 		rouge =   Image_R_pixel(s2, x, y) * kr	+
 			  Image_G_pixel(s2, x, y) * kg	+
 			  Image_B_pixel(s2, x, y) * kb;

Lib/turtle.c

@@ -6,7 +6,7 @@
 #include   <stdio.h>
 #include   <math.h>
 
-#include   "tthimage.h"
+#include   "../tthimage.h"
 
 /*::------------------------------------------------------------------::*/
 int

Lib/warp0.c

@@ -23,7 +23,7 @@ Image_warp_essai_0(Image_Desc *src, Image_Desc *dst, double angle,
 {
 int	x, y, r, g, b;
 long	lfoo;
-double	arad, dheight, dwidth, tmax, dist, va;
+double	arad, dheight, dwidth, tmax, dist;
 int	ofx, ofy;
 
 dheight = (double)dst->height;
@@ -31,28 +31,23 @@ dwidth  = (double)dst->width;
 
 lfoo = ((dst->height*dst->height)+(dst->width*dst->width));
 tmax = sqrt((double)lfoo) / 2.0;
-va = angle / 360.0;
 
+#if DEBUG_LEVEL
 fprintf(stderr, "%s : %d,%d dh = %f  dw = %f  tmax = %f\n", __func__, 
 			xc, yc, dheight, dwidth, tmax);
+#endif
 
-for (y=0; y<dst->height; y++)
+for (y=0; y<dst->height; y++) {
-	{
+	/* printf("------- Ligne %d -----------------\n", y); */
-	/*
-	printf("------- Ligne %d -----------------\n", y);
-	*/
 	arad = ((double)y / dheight) * M_PI;	
 
-	for (x=0; x<dst->width; x++)
+	for (x=0; x<dst->width; x++) {
-		{
 		dist = (double)x / dwidth;
 
 		ofx = xc + (int)(sin(arad)*dist*tmax);
 		ofy = yc + (int)(cos(arad)*dist*tmax);
 
-		/*
+		/* printf("%15f  %15f   %6d  %6d\n", arad, dist, ofx, ofy); */
-		printf("%15f  %15f   %6d  %6d\n", arad, dist, ofx, ofy); 
-		*/
 
 		if ( ofx>=0 && ofx<src->width && ofy>=0 && ofy<src->height )
 			{
@@ -67,7 +62,7 @@ for (y=0; y<dst->height; y++)
 		}
 	}
 
-return FUNC_NOT_FINISH;
+return FUNC_IS_BETA;
 }
 /*::------------------------------------------------------------------::*/
 int

Lib/warp1.c

@@ -30,11 +30,9 @@ my = dst->height / 2;
 sincalc = sin(arad);
 coscalc = cos(arad);
 
-for (xd=0; xd<dst->width; xd++)
+for (xd=0; xd<dst->width; xd++)	{
-	{
 	fxd = (double)(xd-mx);
-	for (yd=0; yd<dst->height; yd++)
+	for (yd=0; yd<dst->height; yd++) {
-		{
 		fyd = (double)(yd-my);
 		fxs = fxd * coscalc - fyd * sincalc;
 		fys = fxd * sincalc + fyd * coscalc;
@@ -42,15 +40,14 @@ for (xd=0; xd<dst->width; xd++)
 		xs = (int)fxs + mx;
 		ys = (int)fys + my;
 
-		if (xs>=0 && xs<src->width && ys>=0 && ys<src->height)
+		if (xs>=0 && xs<src->width && ys>=0 && ys<src->height) {
-			{
 			/* Image_getRGB(src, xs, ys, &r, &g, &b); */
 			r = (src->Rpix[ys])[xs];
 			g = (src->Gpix[ys])[xs];
 			b = (src->Bpix[ys])[xs];
 			}
 		else
-			{ r = g = b = 142; }
+			{ r = g = b = 127; }
 
 		/* Image_plotRGB(dst, xd, yd, r, g, b); */
 		(dst->Rpix[yd])[xd] = r;
@@ -93,11 +90,9 @@ coscalc = cos(arad);
 fxs = fys = 0.0;	/* ? hein ? */
 foo = 0;
 
-for (xd=0; xd<dst->width; xd++)
+for (xd=0; xd<dst->width; xd++) {
-	{
 	fxd = (double)(xd-mx);
-	for (yd=0; yd<dst->height; yd++)
+	for (yd=0; yd<dst->height; yd++) {
-		{
 		fyd = (double)(yd-my);
 
 
@@ -106,6 +101,7 @@ for (xd=0; xd<dst->width; xd++)
 
 			/* MAIS C'EST PAS ENCORE FINI CE TRUC ? */
 			/* 4 mai 2007: ben non, ya rien :) */
+			/* 5 juillet 2022 : toujours pas fait ??? */
 
 return FULL_NUCKED;
 }

Lib/warp2.c

@@ -4,6 +4,7 @@
 */
 
 #include   <stdio.h>
+#include   <stdlib.h>
 #include   <math.h>
 #include   "../tthimage.h"
 
@@ -19,7 +20,7 @@ int	x, y;
 int	x2, y2, foo;
 
 #if DEBUG_LEVEL
-fprintf(stderr, "*** Image_shift_xy: work in progress...\n");
+fprintf(stderr, "*** %s: work in progress...\n", __func__);
 fprintf(stderr, "src=%p dst=%p ox=%d oy=%d\n", src, dst, ox, oy);
 #endif
 
@@ -62,23 +63,55 @@ return FUNC_IS_BETA;		/* et elle coredumpe ? */
 /* OPTIMIZED FOR SPEED */
 int Image_shift_x(Image_Desc *src, Image_Desc *dst, int ox)
 {
+unsigned char	*buffer;
+int		foo, line;
 
 #if DEBUG_LEVEL
 fprintf(stderr, "*** %s : work in progress...\n", __func__);
 fprintf(stderr, "%p -> sX(%d) -> %p\n", src, ox, dst);
 #endif
 
+if ( (foo=Image_compare_desc(src, dst)) )
+    {
+    fprintf(stderr, "%s: images are differents %d\n", __func__, foo);
+    return foo;
+    }
+
+if (NULL==(buffer=malloc(src->width))) {
+	fprintf(stderr, "%s: malloc(%d) fail.\n", __func__, src->width);
+#if MUST_ABORT
+	abort();
+#endif
+	exit(1);
+	}
+
+for (line=0; line<src->width; line++) {
+	
+	/* do something here */
+
+	}
+
+free(buffer);
+
 return FULL_NUCKED;
 }
 /*::------------------------------------------------------------------::*/
 /* OPTIMIZED FOR SPEED */
 int Image_shift_y(Image_Desc *src, Image_Desc *dst, int oy)
 {
+int		foo;
+
 #if DEBUG_LEVEL
 fprintf(stderr, "*** %s : work in progress...\n", __func__);
 fprintf(stderr, "%p -> sY(%d) -> %p\n", src, oy, dst);
 #endif
 
+if ( (foo=Image_compare_desc(src, dst)) )
+    {
+    fprintf(stderr, "%s: images are differents %d\n", __func__, foo);
+    return foo;
+    }
+
 return FULL_NUCKED;
 }
 /*::------------------------------------------------------------------::*/

Paramakes.mk

@@ -1,5 +1,6 @@
 #
 #		GLOBAL MAKE CONFIGURATION
+#		For the "tTh" image library
 #
 
 DESTDIR=/usr/local
@@ -18,9 +19,10 @@ HTML_DIR=$(DESTDIR)/html
 #	--> see file 'PORTING.txt' for porting tips on misc
 #	    architextures (just sparc64 for now)
 #
+# 		use -Wmissing-prototypes ?
 
 LIBIMG_OPT=-DFORCE_ABORT=1 -DDEBUG_LEVEL=0 -DIMGCOMMENT=0
-CC_OPTS=-Wall -W -g -ansi  -Wmissing-prototypes -fPIC -no-pie
+CC_OPTS=-Wall -W -g -ansi -O3  -fPIC -no-pie
 CC_HACKS=-DNEED_ALLOCA_H 
 CFLAGS= $(CC_OPTS)			\
 	$(LIBIMG_OPT)			\

Tests/Makefile

@@ -0,0 +1,14 @@
+#-----------------------------------------------------------------
+
+include ../Paramakes.mk
+
+DEPS = ../tthimage.h ../Paramakes.mk Makefile
+
+all:	t_t16x24
+
+#-----------------------------------------------------------------
+
+t_t16x24:	t_t16x24.c $(DEPS)  ../libtthimage.a
+	gcc $(CFLAGS) $< ../libtthimage.a -o $@
+
+#-----------------------------------------------------------------

Tests/README.md

@@ -2,3 +2,7 @@
 
 Tester, c'est douter.
 
+
+## Mais encore ?
+
+Dans le répertoire `Lib/` il y a un `essais.c` assez prometeur.

Tests/a.sh

@@ -0,0 +1,20 @@
+#!/bin/bash
+
+SRC="/tmp/src.tga"
+BW="/tmp/bw.tga"
+
+DST="foo.tga"
+
+../Tools/tga_tools version
+
+../Tools/tga_tools mk_rgb $SRC 800 600 30 40 50
+../Tools/tga_effects $SRC noise $SRC 255
+../Tools/tga_effects $SRC noise $SRC 255
+# display $SRC
+
+../Tools/tga_effects $SRC gray $BW
+# display $BW
+
+../Tools/tga_combine $SRC $BW circle0 $DST 0
+display $DST
+

Tests/t_t16x24.c

@@ -18,6 +18,10 @@ RGBA		encre, papier;
 img = Image_TGA_alloc_load(tgasrc);
 
 foo = Image_t16x24_txtload("16x24thin", NULL, 0);
+if (foo) {
+	fprintf(stderr, "%s err %d loading font '16x24thin'\n", __func__, foo);
+	return foo;
+	}
 
 encre.r = 0;	encre.g = 255;	encre.b = 100;	encre.a = 255;
 papier.r = 255;	papier.b = 0;	papier.g = 0;	papier.a = 200;
@@ -31,9 +35,7 @@ return -1;
 /*::------------------------------------------------------------------::*/
 int main(int argc, char *argv[])
 {
-char	*fichier;
 int		foo;
-Image_Desc	*image;
 
 fprintf(stderr, "-------------- %s ------------\n", argv[0]);
 foo = Image_t16x24_chars_map("16x24thin", "all16x24chars.tga", 0);

Tools/README.md

@@ -39,6 +39,7 @@ La gestion de la ligne de commande est désastreuse. **À REFAIRE**
 
 Pas mal de façons de mettre un cadre sur l'image.
 Niveau de kitchitude assez élevé.
+Paramètres mal documentés.
 
 ## tga_combine
 

Tools/fonctions.c

@@ -127,7 +127,7 @@ memset(prect, 0, sizeof(Image_Rect));
 
 cptr = strdup(str);
 #if DEBUG_LEVEL
-fprintf(stder, "copie dans cptr %p\n", cptr);
+fprintf(stderr, "copie dans cptr %p\n", cptr);
 #endif
 
 idx = 0;
@@ -135,6 +135,9 @@ cptr = strtok(cptr, ",");
 while (NULL != cptr)	{
 	fprintf(stderr, "%3d %p = '%s'\n", idx, cptr, cptr);
 	foo = sscanf(cptr, "%d", &val);
+	/*
+	 *   no error check ?
+	 */
 	fprintf(stderr, "val = %d\n", val);
 	switch (idx) {
 		case 0:		prect->x = val;		break;
@@ -227,7 +230,7 @@ for (foo=prem, idxt=0; foo<argc; foo++, idxt++)
 
 	case 'd':
 		/* the 'd' is for 'double precision', not for 'decimal' */
-		if (sscanf(argv[foo], "%lf", &flottant)==1)
+		if (1 == sscanf(argv[foo], "%lf", &flottant))
 			{
 			params[idxt].type = 'd';
 			params[idxt].p.d = flottant;
@@ -298,8 +301,7 @@ fflush(stdout);
 
 int	GIP(int rang)
 {
-if (rang<0 || params[rang].type!='i')
+if (rang<0 || params[rang].type!='i') {
-	{
 	fprintf(stderr, "erreur GIP %d\n", rang);
 	exit(5);
 	}
@@ -308,8 +310,7 @@ return params[rang].p.i;
 
 int	GCP(int rang)
 {
-if (rang<0 || params[rang].type!='c')
+if (rang<0 || params[rang].type!='c') {
-	{
 	fprintf(stderr, "erreur GCP %d\n", rang);
 	exit(5);
 	}
@@ -322,8 +323,7 @@ int	GIPdef(int rang, int def)
 #if DEBUG_LEVEL
 fprintf(stderr, "Warning !   %s is not tested\n", __func__);
 #endif
-if (rang<0 || params[rang].type!='i')
+if (rang<0 || params[rang].type!='i') {
-	{
 	return def;
 	}
 return params[rang].p.i;
@@ -334,8 +334,7 @@ char *	GSP(int rang)
 #if DEBUG_LEVEL > 1
 fprintf(stderr, "GetStringParameter(%d)\n", rang);
 #endif
-if (rang<0 || params[rang].type!='s')
+if (rang<0 || params[rang].type!='s') {
-	{
 	fprintf(stderr, "erreur GSP %d\n", rang);
 	exit(5);
 	}
@@ -347,8 +346,7 @@ return params[rang].p.s;
 
 double	GDP(int rang)
 {
-if (rang<0 || params[rang].type!='d')
+if (rang<0 || params[rang].type!='d') {
-	{
 	fprintf(stderr, "erreur GDP %d\n", rang);
 	exit(5);
 	}
@@ -357,8 +355,7 @@ return params[rang].p.d;
 
 int	GFP(int rang)
 {
-if (rang<0 || params[rang].type!='f')
+if (rang<0 || params[rang].type!='f') {
-	{
 	fprintf(stderr, "erreur GFP %d\n", rang);
 	exit(5);
 	}
@@ -395,8 +392,7 @@ fprintf(stderr, "%s : %s, argc=%d\n", __func__, argv[0], argc);
 envvar = getenv(NOM_VAR_ENV_VERBOSE);
 if ( (envvar!=NULL) && !strcmp(envvar, "yes") )		flag = 1;
 
-if (flag || force)
+if (flag || force) {
-	{
 	fprintf(stderr, "TGA(%d) %d arg:", getpid(), argc);
 	for (foo=0; foo<argc; foo++)
 		fprintf(stderr, " %s", argv[foo]);
@@ -410,7 +406,7 @@ int	set_new_seed(int k)
 char		*ptr;
 long		seed;
 
-/* if (k)	fprintf(stderr, "%s: k %d\n", __func__, k); */
+if (k)	fprintf(stderr, "%s: k %d\n", __func__, k); 
 
 if (NULL==(ptr=getenv("FIXED_SEED"))) {
 	/* no fixed seed in context, doing semi-random */

Tools/tga_applymap.c

@@ -17,7 +17,7 @@ fprintf(stderr, "  compiled %s at %s\n", __DATE__, __TIME__);
 
 fprintf(stderr, "Usage:\n\ttga_applymap M src.tga color.map dst.tga\n");
 fprintf(stderr, "       M is 1 or 2\n");
-Image_print_version(0);
+if (flag) Image_print_version(0);
 exit(5);
 }
 /*::------------------------------------------------------------------::*/
@@ -33,34 +33,29 @@ if (argc==2 && !strcmp(argv[1], "-?"))	usage(1);
 
 if (argc != 5) usage(0);
 
-if ( (src=Image_TGA_alloc_load(argv[2])) == NULL )
+if ( (src=Image_TGA_alloc_load(argv[2])) == NULL ) {
-	{
 	fprintf(stderr, "can't load '%s'\n", argv[2]);
 	exit(1);
 	}
 
-if ( (foo=Image_load_color_Map(argv[3], "map", &map)) )
+if ( (foo=Image_load_color_Map(argv[3], "map", &map)) ) {
-	{
 	fprintf(stderr, "%s: %s: err%d %s\n", argv[0], argv[3], 
 					foo, Image_err2str(foo));
 	exit(1);
 	}
 
-if (must_be_verbose())
+if (must_be_verbose()) {
-	{
 	fprintf(stderr, "il y a %d couleurs dans la palette '%s'\n",
 			map.nbre, argv[3]);
 	}
 
-if ( (dst=Image_clone(src, 0))==NULL )
+if ( (dst=Image_clone(src, 0))==NULL ) {
-	{
 	fprintf(stderr, "can't clone %p, exiting...\n", src);
 	exit(2);
 	}
 
 /* ----------- */
-switch (argv[1][0])
+switch (argv[1][0]) {
-	{
 	default:
 	case '1':
 		foo=Image_apply_Map(src, dst, &map);
@@ -74,21 +69,18 @@ switch (argv[1][0])
 	}
 /* ----------- */
 
-if (foo)
+if (foo) {
-	{
 	fprintf(stderr, "%s: apply map: erreur %d: %s\n", 
 					argv[0], foo, Image_err2str(foo));
 	}
 
 foo = Image_TGA_save(argv[4], dst, 0);
-if (foo)
+if (foo) {
-	{
 	fprintf(stderr, "%s: TGA_save: err #%d\n\t\t %s\n",
 			argv[0], foo, Image_err2str(foo));
 	exit(1);
 	}
 
-fprintf(stderr, "apply map ok\n");
 exit (0);
 }
 /*::------------------------------------------------------------------::*/

Tools/tga_combine.c

@@ -34,6 +34,7 @@
 #define MIX_WAOU	80
 #define MIX_WAUO	81
 #define MIX_CIRCLE0	84
+#define MIX_CIRCLE1	85		/* new 6 juillet 2022 */
 #define MIX_HDEG	100
 #define MIX_VDEG	101
 #define MIX_PROTO	110
@@ -77,6 +78,7 @@ mot_clef les_types[] =
 	{ "waou",	MIX_WAOU,	"iiii",	h_waou		},
 	{ "wauo",	MIX_WAUO,	"i",	h_wauo		},
 	{ "circle0",	MIX_CIRCLE0,	"i",	h_circle0	},
+	{ "circle1",	MIX_CIRCLE1,	"i",	"don't know"	},
 
 	{ "hdeg",	MIX_HDEG,	"f",	h_deg		},
 	{ "vdeg",	MIX_VDEG,	"f",	h_deg		},
@@ -254,6 +256,10 @@ switch (mode)
 	case MIX_CIRCLE0:
 		foo = Image_combine_cercle_flou(s1, s2, d, 0);
 		break;
+	case MIX_CIRCLE1:
+		fprintf(stderr, "pid %d is circle trashing\n", getpid());
+		foo = Image_combine_cercle_flou(s1, s2, d, 1);
+		break;
 
 /* FIXME 16 sept 2009 : je pense que hdeg et vdeg sont inverses */
 	case MIX_HDEG:

Tools/tga_effects.c

@@ -29,6 +29,7 @@
 #define		EFF_PIXELY	34	/* new 30 mars 2007 */
 #define		EFF_FIVE	35	/* new 16 dec 2007 */
 #define		EFF_WARP_0	36	/* new 17 janv 2015 */
+#define		EFF_ROTULACION	37	/* new  6 juillet 2022 */
 #define		EFF_RECURSE	40
 #define		EFF_RGBMSKH	41
 #define		EFF_RGBMSKV	42
@@ -67,6 +68,8 @@ mot_clef mots_clef[] =
 { "gray",	EFF_GRAY,	"", 	""				},
 { "grayk",	EFF_GRAYK,	"iii", 	"3 coefs"			},
 { "mirror",	EFF_MIRROR,	"", 	""				},
+{ "updown",	EFF_UPDOWN,	"",	"upside down"			},
+{ "rotulacion",	EFF_ROTULACION,	"d",	"angle in degree"		},
 { "extrbits0",	EFF_EXTRBIT0,	"iii",	"shifts for r, g & b"		},
 { "mosaic",	EFF_MOSAIC,	"",	"?"				},
 { "mosaic0",	EFF_MOSAIC0,	"iif",	"?"				},
@@ -74,7 +77,7 @@ mot_clef mots_clef[] =
 { "negate",	EFF_NEGATE,	"", 	""				},
 { "seuil",	EFF_SEUIL,	"iii",	"rgb thresholds"		},
 { "degoule",	EFF_DEGOULE,	"ii",	"k1 & k2 ? wtf ?"		},
-{ "noise",	EFF_NOISE,	"i", 	"0..100"			},
+{ "noise",	EFF_NOISE,	"i", 	"0..255"			},
 { "pixelX",	EFF_PIXELX,	"",	"prototype"			},
 { "pixelY",	EFF_PIXELY,	"",	"prototype"			},
 { "efive",	EFF_FIVE,	"",	"got it, code it"		},
@@ -93,7 +96,6 @@ mot_clef mots_clef[] =
 { "sinwave1",	EFF_SINW1,	"dddddd", "strange effect"		},
 { "swapcol",	EFF_SWAPCOL,	"s",	"rg rb bg"			},
 { "swapnibble",	EFF_SWAPNIBBLE,	"",	"swap all pix nibbles"		},
-{ "updown",	EFF_UPDOWN,	"",	"upside down"			},
 { "shift_xy",	EFF_SHIFT_XY,	"ii",	"les deux offsets"		}, 
 { "water",	EFF_WATER,	"i", 	"'par' is water distance"	},
 /* { "fukung",	EFF_FUKUNG,	"i",	"OMG ! WTF ?"			}, */
@@ -110,18 +112,16 @@ mot_clef mots_clef[] =
 /*::------------------------------------------------------------------::*/
 void usage(int flag)
 {
-fprintf(stderr, "*** tga_effects v 0.1.56 [%s] %s\n",
+fprintf(stderr, "*** tga_effects v 0.1.58 [%s] %s\n",
 				TGA_OUTILS_VERSION, TGA_OUTILS_COPYLEFT);
 
 fprintf(stderr, "\nUsage:\n");
 fprintf(stderr, "\ttga_effects <src.tga> EFF <dst.tga> [p1] ... [p8]\n");
-if (flag)
+if (flag) {
-	{
 	Image_print_version(0);
 	liste_mots_clefs(mots_clef, 42);
 	}
-else
+else	{
-	{
 	fprintf(stderr, "\ttry 'tga_effects list' for a list.\n");
 	}
 exit(5);
@@ -236,7 +236,7 @@ srand(getpid());
 idx = cherche_mot_clef(argv[2], mots_clef, &commande, &nbargs);
 if (idx < 0)
 	{
-	fprintf(stderr, "tga_effects: mot-clef %s inconnu...\n", argv[2]);
+	fprintf(stderr, "tga_effects: mot-clef '%s' inconnu...\n", argv[2]);
 	exit (5);
 	}
 
@@ -284,6 +284,11 @@ switch (commande)
 	case EFF_MIRROR:
 		foo = Image_mirror(src, dst, 0);
 		break;
+	case EFF_ROTULACION:			 /* new 6 juillet 2022 */
+		angle = GDP(0);
+		fprintf(stderr, "%s: angle rotulacion = %f\n", __FILE__, angle);
+		foo = Image_center_rotate(src, dst, angle);
+		break;
 	case EFF_EXTRBIT0:
 		foo = Image_extrbits_0(src, dst, GIP(0), GIP(1), GIP(2));
 		break;
@@ -326,9 +331,10 @@ switch (commande)
 	case EFF_WARP_0:
 		angle = 33.5;
 		xc = GIP(1); yc = GIP(2);
-		fprintf(stderr, "WARP_0 %f %d %d\n", angle, xc, yc);
 		foo = Image_warp_essai_0(src, dst, angle, xc, yc);
-		fprintf(stderr, "    -> %d\n", foo);
+#if DEBUG_LEVEL
+		fprintf(stderr, "warp0 %f %d %d > %d\n", angle, xc, yc, foo);
+#endif
 		break;
 	case EFF_RECURSE:
 #if DEBUG_LEVEL

Tools/tga_export.c

@@ -18,6 +18,7 @@
 #define		PCX8	60
 #define		PCX24	61
 #define		PGMHF	80
+#define		TIFF	90
 
 mot_clef mots_clef[] =
 {
@@ -28,6 +29,7 @@ mot_clef mots_clef[] =
 { "pcx8",	PCX8,		"i",	"plop"				},
 { "pcx24",	PCX24,		"i",	"plup"				},
 { "pgmhf",	PGMHF,		"",	"height fields for POV"		},
+{ "tiff",	TIFF,		"",	""				},
 { NULL,		0,		NULL,	NULL				}
 };
 
@@ -35,13 +37,12 @@ mot_clef mots_clef[] =
 
 void usage(int flag)
 {
-fprintf(stderr, "*** tga_export v 0.0.9 [%s] %s\n",
+fprintf(stderr, "*** tga_export v 0.0.10 [%s] %s\n",
 				TGA_OUTILS_VERSION, TGA_OUTILS_COPYLEFT);
 
 fprintf(stderr, "tga_export source.tga format destination.xxx [params]\n\n");
 
-if (flag)
+if (flag) {
-	{
 	liste_mots_clefs(mots_clef, 42);
 	}
 exit(5);
@@ -65,13 +66,11 @@ if (argc < 4)		usage(1);
 
 /* recherche du type d'exportation demandé */
 idx = cherche_mot_clef(argv[2], mots_clef, &commande, &nbargs);
-if (idx < 0)
+if (idx < 0) {
-	{
 	fprintf(stderr, "tga_export: format %s inconnu...\n", argv[2]);
 	exit (5);
 	}
-if ( (argc-nbargs) != FIRST_PARAM )
+if ( (argc-nbargs) != FIRST_PARAM ) {
-	{
 	fprintf(stderr, "%s: bad number of parameters\n", argv[0]);
 	exit(5);
 	}
@@ -79,14 +78,12 @@ if ( (argc-nbargs) != FIRST_PARAM )
 /* analyse des paramètres */
 foo = parse_parametres(argc, argv, mots_clef[idx].ptypes, FIRST_PARAM);
 
-if ( (img=Image_TGA_alloc_load(argv[1]))==NULL )
+if ( (img=Image_TGA_alloc_load(argv[1]))==NULL ) {
-	{
 	fprintf(stderr, "tga_export: can't load '%s'\n", argv[1]);
 	exit(5);
 	}
 
-switch (commande)
+switch (commande) {
-	{
 	case PGM0:
 		foo = Image_wr_pgm_0(argv[3], img, GCP(0));
 		break;
@@ -109,10 +106,10 @@ switch (commande)
 		break;
 	}
 
-if (foo)
+if (foo) {
-	{
 	fprintf(stderr, "tga_export (%s) ", argv[2]);
 	Image_print_error("ecriture fichier", foo);
+	exit(1);
 	}
 
 return 0;

Tools/tga_filtres.c

@@ -39,18 +39,16 @@ mot_clef mots_clef[] =
 /*::------------------------------------------------------------------::*/
 void usage(int flag)
 {
-fprintf(stderr, "*** tga_filtres v 0.0.17 [%s] %s\n",
+fprintf(stderr, "*** tga_filtres v 0.0.18 [%s] %s\n",
 				TGA_OUTILS_VERSION, TGA_OUTILS_COPYLEFT);
 
 fprintf(stderr, "\nUsage:\n");
 fprintf(stderr, "\ttga_filtres <src.tga> FILTR <dst.tga> [p1] ... [pn]\n");
-if (flag)
+if (flag) {
-	{
 	Image_print_version(0);
 	liste_mots_clefs(mots_clef, 42);
 	}
-else
+else {
-	{
 	fprintf(stderr, "\ttry 'tga_filtres list' for a list.\n");
 	}
 exit(5);
@@ -77,8 +75,7 @@ srand(getpid());
 
 /* recherche du type d'effet demandé */
 idx = cherche_mot_clef(argv[2], mots_clef, &commande, &nbargs);
-if (idx < 0)
+if (idx < 0) {
-	{
 	fprintf(stderr, "tga_filtres: mot-clef %s inconnu...\n", argv[2]);
 	exit (5);
 	}
@@ -88,8 +85,7 @@ fprintf(stderr, "%s --> idx=%d, commande=%d, %d args\n",
 fprintf(stderr, "argc = %d\n", argc);
 #endif
 
-if ( (argc-nbargs) != FIRST_PARAM )
+if ( (argc-nbargs) != FIRST_PARAM ) {
-	{
 	fprintf(stderr, "%s: bad number of parameters\n", argv[0]);
 	exit(5);
 	}
@@ -97,14 +93,12 @@ if ( (argc-nbargs) != FIRST_PARAM )
 /* analyse des paramètres */
 foo = parse_parametres(argc, argv, mots_clef[idx].ptypes, FIRST_PARAM);
 
-if ((src = Image_TGA_alloc_load(argv[1]))==NULL)
+if ((src = Image_TGA_alloc_load(argv[1]))==NULL) {
-	{
 	fprintf(stderr, "tga_filtres: can't load image %s\n", argv[1]);
 	exit(5);
 	}
 
-if ( (dst=Image_clone(src, 0)) == NULL )
+if ( (dst=Image_clone(src, 0)) == NULL ) {
-	{
 	fprintf(stderr, "tga_filtres: can't clone %p\n", src);
 	exit(1);
 	}
@@ -145,9 +139,10 @@ switch (commande)
 		break;
 	}
 
-if (foo)
+if (foo) {
-	Image_print_error("filtrage ", foo);
+	Image_print_error("tga_filtres ", foo);
-
+	exit(1);
+	}
 foo = Image_TGA_save(argv[3], dst, 0);
 
 return 0;

Tools/tga_incrust.c

@@ -84,13 +84,11 @@ if (must_be_verbose())
 #endif
 
 idx = cherche_mot_clef(argv[3], mots_clef, &commande, &nbargs);
-if (idx < 0)
+if (idx < 0) {
-	{
 	fprintf(stderr, "tga_incrust: mot-clef '%s' inconnu...\n", argv[3]);
 	exit (5);
 	}
-if ( (argc-nbargs) != FIRST_PARAM )
+if ( (argc-nbargs) != FIRST_PARAM ) {
-	{
 	fprintf(stderr, "%s: bad number of parameters\n", argv[0]);
 #if DEBUG_LEVEL
 	fprintf(stderr, "argc=%d nbargs=%d FIRST_PARAM=%d\n",
@@ -106,14 +104,12 @@ foo = parse_parametres(argc, argv, mots_clef[idx].ptypes, FIRST_PARAM);
 fprintf(stderr, "parse params -> %d\n", foo);
 #endif
 
-if (NULL==(where=Image_TGA_alloc_load(argv[1])))
+if (NULL==(where=Image_TGA_alloc_load(argv[1]))) {
-	{
 	fprintf(stderr, "can't load %s\n", argv[1]);
 	exit(2);
 	}
 
-if (NULL==(what=Image_TGA_alloc_load(argv[2])))
+if (NULL==(what=Image_TGA_alloc_load(argv[2]))) {
-	{
 	fprintf(stderr, "can't load %s\n", argv[2]);
 	exit(2);
 	}
@@ -134,8 +130,7 @@ switch (commande)
 Image_DeAllocate(what);			free(what);
 
 foo = Image_TGA_save(argv[4], where, 0);
-if (foo)
+if (foo) {
-	{
 	fprintf(stderr, "save -> %d\n", foo);
 	}
 Image_DeAllocate(where);		free(where);

build.sh

@@ -11,3 +11,8 @@ cd Tools
 echo "========== in $PWD"
 make 
 cd ..
+
+cd Tests
+echo "========== in $PWD"
+make 
+cd ..

tthimage.h

@@ -4,7 +4,7 @@
 	http:///la.buvette.org/devel/libimage/
 */
 #ifndef IMAGE_VERSION_STRING
-	#define IMAGE_VERSION_STRING "0.4.51 pl 8"
+	#define IMAGE_VERSION_STRING "0.4.51 pl 16"
 
 /*::------------------------------------------------------------------::*/
 /*