post-configure:

	${REINPLACE_CMD} -e 's,-std=gnu99,,'	\

		${WRKSRC}/Makefile ${WRKSRC}/*/Makefile

check test regression-test: build

	${MAKE} -C ${WRKSRC}/test testil

	cd ${WRKSRC}/test && ${SH} format_test/format_checks.sh

See https://sourceforge.net/p/openil/patches/41/

This patch improves alpha-compositing in DevIL.

--- src-IL/src/il_devil.c	(revision 1654)

+++ src-IL/src/il_devil.c	(working copy)

@@ -665,10 +665,10 @@

 	ILuint		c;

 	ILuint		StartX, StartY, StartZ;

 	ILboolean	DestFlipped = IL_FALSE;

+	ILboolean	DoAlphaBlend = IL_FALSE;

 	ILubyte 	*SrcTemp;

-	ILfloat		Back;

-

-	// Check if the desiination image really exists

+	ILfloat		ResultAlpha;

+	// Check if the destination image really exists

 	if (DestName == 0 || iCurImage == NULL) {

 		ilSetError(IL_ILLEGAL_OPERATION);

 		return IL_FALSE;

@@ -680,6 +680,9 @@

 		DestFlipped = IL_TRUE;

 		ilFlipImage();

 	}

+	//determining destination alpha support

+	DoAlphaBlend = ilIsEnabled(IL_BLIT_BLEND);

+

 	//DestOrigin = Dest->Origin;

 	ilBindImage(Source);

@@ -688,7 +691,9 @@

 		ilSetError(IL_INVALID_PARAM);

 		return IL_FALSE;

 	}

-	

+	//determining source alpha support

+	DoAlphaBlend &= ilIsEnabled(IL_BLIT_BLEND);

+

 	Src = iCurImage;

 	//@TODO test if coordinates are inside the images (hard limit for source)

@@ -737,38 +742,49 @@

 					const ILuint  SrcIndex  = (z+SrcZ)*ConvSizePlane + (y+SrcY)*ConvBps + (x+SrcX)*Dest->Bpp;

 					const ILuint  DestIndex = (z+DestZ)*Dest->SizeOfPlane + (y+DestY)*Dest->Bps + (x+DestX)*Dest->Bpp;

 					const ILuint  AlphaIdx = SrcIndex + bpp_without_alpha;

-					ILfloat Front = 0;

+					ILfloat FrontAlpha = 0; // foreground opacity

+					ILfloat BackAlpha = 0;	// background opacity

 					switch (Dest->Type)

 					{

 						case IL_BYTE:

 						case IL_UNSIGNED_BYTE:

-							Front = Converted[AlphaIdx]/((float)IL_MAX_UNSIGNED_BYTE);

+							FrontAlpha = Converted[AlphaIdx]/((float)IL_MAX_UNSIGNED_BYTE);

+							BackAlpha = Dest->Data[AlphaIdx]/((float)IL_MAX_UNSIGNED_BYTE);

 							break;

 						case IL_SHORT:

 						case IL_UNSIGNED_SHORT:

-							Front = ((ILshort*)Converted)[AlphaIdx]/((float)IL_MAX_UNSIGNED_SHORT);

+							FrontAlpha = ((ILshort*)Converted)[AlphaIdx]/((float)IL_MAX_UNSIGNED_SHORT);

+							BackAlpha = ((ILshort*)Dest->Data)[AlphaIdx]/((float)IL_MAX_UNSIGNED_SHORT);

 							break;

 						case IL_INT:

 						case IL_UNSIGNED_INT:

-							Front = ((ILint*)Converted)[AlphaIdx]/((float)IL_MAX_UNSIGNED_INT);

+							FrontAlpha = ((ILint*)Converted)[AlphaIdx]/((float)IL_MAX_UNSIGNED_INT);

+							BackAlpha = ((ILint*)Dest->Data)[AlphaIdx]/((float)IL_MAX_UNSIGNED_INT);

 							break;

 						case IL_FLOAT:

-							Front = ((ILfloat*)Converted)[AlphaIdx];

+							FrontAlpha = ((ILfloat*)Converted)[AlphaIdx];

+							BackAlpha = ((ILfloat*)Dest->Data)[AlphaIdx];

 							break;

 						case IL_DOUBLE:

-							Front = (ILfloat)(((ILdouble*)Converted)[AlphaIdx]);

+							FrontAlpha = (ILfloat)(((ILdouble*)Converted)[AlphaIdx]);

+							BackAlpha = (ILfloat)(((ILdouble*)Dest->Data)[AlphaIdx]);

 							break;

 					}

-					Back = 1.0f - Front;

-					// In case of Alpha channel, the data is blended. Keeps the original alpha.

-					if (ilIsEnabled(IL_BLIT_BLEND)) {

+					

+					// In case of Alpha channel, the data is blended.

+					// Computes composite Alpha

+					if (DoAlphaBlend)

+					{

+						ResultAlpha = FrontAlpha + (1.0f - FrontAlpha) * BackAlpha;

 						for (c = 0; c < bpp_without_alpha; c++)

 						{

-							Dest->Data[DestIndex + c] = 

-								(ILubyte)(Converted[SrcIndex + c] * Front

-											+ Dest->Data[DestIndex + c] * Back);

+							Dest->Data[DestIndex + c] = (ILubyte)( 0.5f + 

+								(Converted[SrcIndex + c] * FrontAlpha + 

+								(1.0f - FrontAlpha) * Dest->Data[DestIndex + c] * BackAlpha) 

+								/ ResultAlpha);

 						}

+						Dest->Data[AlphaIdx] = (ILubyte)(0.5f + ResultAlpha * (float)IL_MAX_UNSIGNED_BYTE);

 					}

 					else {

 						for (c = 0; c < Dest->Bpp; c++)

See https://sourceforge.net/p/openil/patches/42/

This patch allows luminance BMPs to be saved as straight grayscale, saving

lots of space for colorless images.

--- src-IL/src/il_bmp.c	(revision 1662)

+++ src-IL/src/il_bmp.c	(working copy)

@@ -928,6 +928,28 @@

 		}

 	}

+	if((iCurImage->Format == IL_LUMINANCE) && (iCurImage->Pal.Palette == NULL))

+	{

+		// For luminance images it is necessary to generate a grayscale BGR32

+		//  color palette.  Could call iConvertImage(..., IL_COLOR_INDEX, ...)

+		//  to generate an RGB24 palette, followed by iConvertPal(..., IL_PAL_BGR32),

+		//  to convert the palette to BGR32, but it seemed faster to just

+		//  explicitely generate the correct palette.

+		

+		iCurImage->Pal.PalSize = 256*4;

+		iCurImage->Pal.PalType = IL_PAL_BGR32;

+		iCurImage->Pal.Palette = (ILubyte*)ialloc(iCurImage->Pal.PalSize);

+		

+		// Generate grayscale palette

+		for (i = 0; i < 256; i++)

+		{

+			iCurImage->Pal.Palette[i * 4] = i;

+			iCurImage->Pal.Palette[i * 4 + 1] = i;

+			iCurImage->Pal.Palette[i * 4 + 2] = i;

+			iCurImage->Pal.Palette[i * 4 + 3] = 0;

+		}

+	}

+	

 	// If the current image has a palette, take care of it

 	TempPal = &iCurImage->Pal;

 	if( iCurImage->Pal.PalSize && iCurImage->Pal.Palette && iCurImage->Pal.PalType != IL_PAL_NONE ) {

@@ -948,8 +970,8 @@

 	//BITMAPINFOHEADER, so that the written header refers to

 	//TempImage instead of the original image

-	// @TODO LUMINANCE converted to BGR insteaf of beign saved to luminance

-	if (iCurImage->Format != IL_BGR && iCurImage->Format != IL_BGRA && iCurImage->Format != IL_COLOUR_INDEX) {

+	if ((iCurImage->Format != IL_BGR) && (iCurImage->Format != IL_BGRA) && 

+			(iCurImage->Format != IL_COLOUR_INDEX) && (iCurImage->Format != IL_LUMINANCE)) {

 		if (iCurImage->Format == IL_RGBA) {

 			TempImage = iConvertImage(iCurImage, IL_BGRA, IL_UNSIGNED_BYTE);

 		} else {

See https://sourceforge.net/p/openil/patches/43/

This patch will cause TIFFs with only a single color channel to be

saved as such, rather than as RGB.

--- src-IL/src/il_tiff.c	(revision 1663)

+++ src-IL/src/il_tiff.c	(working copy)

@@ -987,11 +987,15 @@

 	TIFFSetField(File, TIFFTAG_IMAGEWIDTH, TempImage->Width);

 	TIFFSetField(File, TIFFTAG_IMAGELENGTH, TempImage->Height);

 	TIFFSetField(File, TIFFTAG_COMPRESSION, Compression);

-	TIFFSetField(File, TIFFTAG_PHOTOMETRIC, PHOTOMETRIC_RGB);

+	if((TempImage->Format == IL_LUMINANCE) || (TempImage->Format == IL_LUMINANCE_ALPHA))

+		TIFFSetField(File, TIFFTAG_PHOTOMETRIC, PHOTOMETRIC_MINISBLACK);

+	else

+		TIFFSetField(File, TIFFTAG_PHOTOMETRIC, PHOTOMETRIC_RGB);

 	TIFFSetField(File, TIFFTAG_BITSPERSAMPLE, TempImage->Bpc << 3);

 	TIFFSetField(File, TIFFTAG_SAMPLESPERPIXEL, TempImage->Bpp);

-	if (TempImage->Bpp == 4) //TODO: LUMINANCE, LUMINANCE_ALPHA

-		TIFFSetField(File, TIFFTAG_MATTEING, 1);

+	if ((TempImage->Bpp == ilGetBppFormat(IL_RGBA)) ||

+			(TempImage->Bpp == ilGetBppFormat(IL_LUMINANCE_ALPHA)))

+		TIFFSetField(File, TIFFTAG_EXTRASAMPLES, EXTRASAMPLE_ASSOCALPHA);

 	TIFFSetField(File, TIFFTAG_PLANARCONFIG, PLANARCONFIG_CONTIG);

 	TIFFSetField(File, TIFFTAG_ROWSPERSTRIP, 1);

 	TIFFSetField(File, TIFFTAG_SOFTWARE, ilGetString(IL_VERSION_NUM));

See: https://sourceforge.net/p/openil/patches/46/

Add the ability to alter the PNG-compression.

--- include/IL/il.h	(revision 1677)

+++ include/IL/il.h	(working copy)

@@ -377,6 +377,7 @@

 #define IL_PNG_ALPHA_INDEX 0x0724 //XIX : ILint : the color in the palette at this index value (0-255) is considered transparent, -1 for no trasparent color

 #define IL_JPG_PROGRESSIVE         0x0725

 #define IL_VTF_COMP                0x0726

+#define IL_PNG_COMPRESSION         0x0727

 // DXTC definitions

--- src-IL/include/il_states.h	(revision 1677)

+++ src-IL/include/il_states.h	(working copy)

@@ -76,6 +76,7 @@

 	ILboolean	ilJpgProgressive;

 	ILenum		ilDxtcFormat;

 	ILenum		ilPcdPicNum;

+	ILuint		ilPngCompression;

 	ILint		ilPngAlphaIndex;	// this index should be treated as an alpha key (most formats use this rather than having alpha in the palette), -1 for none

 									// currently only used when writing out .png files and should obviously be set to -1 most of the time

--- src-IL/src/il_png.c	(revision 1677)

+++ src-IL/src/il_png.c	(working copy)

@@ -538,6 +538,8 @@

 //	png_init_io(png_ptr, PngFile);

 	png_set_write_fn(png_ptr, NULL, png_write, flush_data);

+	png_set_compression_level(png_ptr, iGetInt(IL_PNG_COMPRESSION));

+

 	switch (iCurImage->Type)

 	{

 		case IL_BYTE:

--- src-IL/src/il_states.c	(revision 1677)

+++ src-IL/src/il_states.c	(working copy)

@@ -70,6 +70,10 @@

 	ilStates[ilCurrentPos].ilPngAlphaIndex = -1;

 	ilStates[ilCurrentPos].ilVtfCompression = IL_DXT_NO_COMP;

+	// Default PNG compression setting as defined in libpng manual:

+	//  http://www.libpng.org/pub/png/libpng-1.2.5-manual.html#section-5.8

+	ilStates[ilCurrentPos].ilPngCompression = 6;

+

 	ilStates[ilCurrentPos].ilTgaId = NULL;

 	ilStates[ilCurrentPos].ilTgaAuthName = NULL;

 	ilStates[ilCurrentPos].ilTgaAuthComment = NULL;

@@ -500,6 +504,9 @@

 		case IL_VTF_COMP:

 			*Param = ilStates[ilCurrentPos].ilVtfCompression;

 			break;

+		case IL_PNG_COMPRESSION:

+			*Param = ilStates[ilCurrentPos].ilPngCompression;

+			break;

 		// Boolean values

 		case IL_CONV_PAL:

@@ -815,6 +822,7 @@

 		ilStates[ilCurrentPos].ilPcdPicNum = ilStates[ilCurrentPos-1].ilPcdPicNum;

 		ilStates[ilCurrentPos].ilPngAlphaIndex = ilStates[ilCurrentPos-1].ilPngAlphaIndex;

+		ilStates[ilCurrentPos].ilPngCompression = ilStates[ilCurrentPos-1].ilPngCompression;

 		// Strings

 		if (ilStates[ilCurrentPos].ilTgaId)

@@ -1159,6 +1167,14 @@

 				return;

 			}

 			break;

+		case IL_PNG_COMPRESSION:

+			// Valid PNG compression settings as defined in libpng manual:

+			//  http://www.libpng.org/pub/png/libpng-1.2.5-manual.html#section-5.8

+			if (Param >= 0 && Param <= 9) {

+				ilStates[ilCurrentPos].ilPngCompression = Param;

+				return;

+			}

+			break;

 		default:

 			ilSetError(IL_INVALID_ENUM);

See https://sourceforge.net/p/openil/patches/47/

From 5ab2eae2939463aba7fd7bf9a37cc43b9d8cdc43 Mon Sep 17 00:00:00 2001

From: Jeff Epler <jepler@unpythonic.net>

Date: Thu, 3 Jun 2010 16:38:46 -0500

Subject: [PATCH] PR20713: fix out of bounds access in iluGaussian

the 'rightmost pixel' case in iluBlurGaussian was the same as the

'leftmost pixel' case, which makes it refer to pixels that are off the

right-hand side of the image by 1 or 2 pixels.  In the final row they

are beyond the end of the image, and if the bytes just beyond the end of

the image are in an unmapped page, the program can segfault.

change the 'rightmost' case to use the pixels to the left of the pixel

being filtered instead.

Signed-off-by: Jeff Epler <jepler@unpythonic.net>

--- src-ILU/src/ilu_filter.c

+++ src-ILU/src/ilu_filter.c

@@ -378,14 +378,14 @@ ILubyte *Filter(ILimage *Image, const ILint *matrix, ILint scale, ILint bias)

 			}

 			for (c = 0; c < Image->Bpp; c++) {

 				Num =   Image->Data[y - Image->Bps + c] * matrix[0] +

-						Image->Data[y - Image->Bps + Image->Bpp + c] * matrix[1]+

-						Image->Data[y - Image->Bps + 2 * Image->Bpp + c] * matrix[2]+

+						Image->Data[y - Image->Bps - Image->Bpp + c] * matrix[1]+

+						Image->Data[y - Image->Bps - 2 * Image->Bpp + c] * matrix[2]+

 						Image->Data[y + c] * matrix[3]+

-						Image->Data[y + Image->Bpp + c] * matrix[4]+

-						Image->Data[y + 2 * Image->Bpp + c] * matrix[5]+

+						Image->Data[y - Image->Bpp + c] * matrix[4]+

+						Image->Data[y - 2 * Image->Bpp + c] * matrix[5]+

 						Image->Data[y + Image->Bps + c] * matrix[6]+

-						Image->Data[y + Image->Bps + Image->Bpp + c] * matrix[7]+

-						Image->Data[y + Image->Bps + 2 * Image->Bpp + c] * matrix[8];

+						Image->Data[y + Image->Bps - Image->Bpp + c] * matrix[7]+

+						Image->Data[y + Image->Bps - 2 * Image->Bpp + c] * matrix[8];

 					Temp = (ILuint)fabs((Num / (ILdouble)scale) + bias);

 					if (Temp > 255)

-- 

1.7.1

See https://sourceforge.net/p/openil/patches/49/ -- this patch allows

DevIL to be configured with ILUT, but without X11:

--- m4/devil-api_checks.m4	2009-03-08 10:10:05.000000000 +0300

+++ m4/devil-api_checks.m4	2012-01-31 17:05:07.163553444 +0400

@@ -137,7 +137,7 @@

                               [main],

                               [dnl The use_x11 var is either "yes" already, or we don't want "no" to be overwritten

                                ILUT_LIBS="-lX11 $ILUT_LIBS"],

-                              [use_x11="no"]) ])

+                              [use_x11="no"]) ], [use_x11="no"])

           TEST_API([shm])

           AS_IF([test "x$enable_shm" = "xyes"],

                 [AC_CHECK_HEADER([X11/extensions/XShm.h],

See https://sourceforge.net/p/openil/patches/50/

--- src-IL/src/il_targa.c	(revision 1678)

+++ src-IL/src/il_targa.c	(working copy)

@@ -219,6 +219,9 @@

 			ilSetError(IL_ILLEGAL_FILE_VALUE);

 			return IL_FALSE;

 	}

+

+	if (bTarga==IL_FALSE)

+		return IL_FALSE;

 	// @JASON Extra Code to manipulate the image depending on

 	// the Image Descriptor's origin bits.

See https://sourceforge.net/p/openil/patches/51/

*** src-ILU/src/ilu_scale2d.c	Wed Oct 28 16:51:50 2009

--- src-ILU/src/ilu_scale2d.c	Tue Dec 18 12:11:08 2012

***************

*** 204,209 ****

--- 204,217 ----

  	ILfloat	SrcX, SrcY;

  	ILuint	iSrcX, iSrcY, iSrcXPlus1, iSrcYPlus1, ulOff, llOff, urOff, lrOff;

+ 	// only downscale is allowed

+ 	assert(ScaleX>0 && ScaleX<=1.0f);

+ 	assert(ScaleY>0 && ScaleY<=1.0f);

+ 

+ 	// scale factors should match images size

+ 	assert( ((ILfloat)Width -0.5f) / ScaleX < Image->Width );

+ 	assert( ((ILfloat)Height-0.5f) / ScaleY < Image->Height );

+ 

  	ImgBps = Image->Bps / Image->Bpc;

  	SclBps = Scaled->Bps / Scaled->Bpc;

***************

*** 213,226 ****

  			for (y = 0; y < Height; y++) {

  				for (x = 0; x < Width; x++) {

  					// Calculate where we want to choose pixels from in our source image.

! 					SrcX = (ILfloat)x / (ILfloat)ScaleX;

! 					SrcY = (ILfloat)y / (ILfloat)ScaleY;

! 					// Integer part of SrcX and SrcY

! 					iSrcX = (ILuint)floor(SrcX);

! 					iSrcY = (ILuint)floor(SrcY);

! 					// Fractional part of SrcX and SrcY

! 					FracX = SrcX - (ILfloat)(iSrcX);

! 					FracY = SrcY - (ILfloat)(iSrcY);

  					// We do not want to go past the right edge of the image or past the last line in the image,

  					//  so this takes care of that.  Normally, iSrcXPlus1 is iSrcX + 1, but if this is past the

--- 221,234 ----

  			for (y = 0; y < Height; y++) {

  				for (x = 0; x < Width; x++) {

  					// Calculate where we want to choose pixels from in our source image.

! 					SrcX = (ILfloat)(x+0.5f) / (ILfloat)ScaleX;

! 					SrcY = (ILfloat)(y+0.5f) / (ILfloat)ScaleY;

! 					// indices of upper-left pixel

! 					iSrcX = (ILuint)(SrcX-0.5f);

! 					iSrcY = (ILuint)(SrcY-0.5f);

! 					// how far SrcX and SrcY are from upper-left pixel center

! 					FracX = SrcX - (ILfloat)(iSrcX) - 0.5f;

! 					FracY = SrcY - (ILfloat)(iSrcY) - 0.5f;

  					// We do not want to go past the right edge of the image or past the last line in the image,

  					//  so this takes care of that.  Normally, iSrcXPlus1 is iSrcX + 1, but if this is past the

See https://sourceforge.net/p/openil/patches/52/

--- src-IL/src/il_pcx.c	(revision 1678)

+++ src-IL/src/il_pcx.c	(working copy)

@@ -375,20 +375,26 @@

 	if (Header->NumPlanes == 1 && Header->Bpp == 1) {

 		for (j = 0; j < iCurImage->Height; j++) {

 			i = 0; //number of written pixels

-			while (i < iCurImage->Width) {

+			Bps = 0;

+			while (Bps<Header->Bps) {

 				if (iread(&HeadByte, 1, 1) != 1)

 					return IL_FALSE;

+				++Bps;

+				// Check if we got duplicates with RLE compression

 				if (HeadByte >= 192) {

 					HeadByte -= 192;

 					if (iread(&Data, 1, 1) != 1)

 						return IL_FALSE;

+					--Bps;

+					// duplicate next byte

 					for (c = 0; c < HeadByte; c++) {

 						k = 128;

 						for (d = 0; d < 8 && i < iCurImage->Width; d++) {

 							iCurImage->Data[j * iCurImage->Width + i++] = ((Data & k) != 0 ? 255 : 0);

 							k >>= 1;

 						}

+						++Bps;

 					}

 				}

 				else {

@@ -408,8 +414,12 @@

 			//If Width/8 is even no padding is needed,

 			//one pad byte has to be read otherwise.

 			//(let's hope the above is true ;-))

-			if(!((iCurImage->Width >> 3) & 0x1))

-				igetc();	// Skip pad byte

+

+			// changed 2012-05-06

+			// Not the good size - don't need it, padding inside data already !

+

+		//	if(!((iCurImage->Width >> 3) & 0x1))

+		//		igetc();	// Skip pad byte

 		}

 	}

 	else if (Header->NumPlanes == 4 && Header->Bpp == 1){   // 4-bit images

Submitted upstream as:

	https://sourceforge.net/p/openil/bugs/212/

--- src-IL/include/il_internal.h	2009-03-08 03:10:08.000000000 -0400

+++ src-IL/include/il_internal.h	2014-12-20 01:11:39.000000000 -0500

@@ -228,5 +228,5 @@

 ILboolean ilLoadBlpF(ILHANDLE File);

 ILboolean ilLoadBlpL(const void *Lump, ILuint Size);

-ILboolean ilIsValidBmp(ILconst_string CONST_RESTRICT FileName);

+ILboolean ilIsValidBmp(ILconst_string FileName);

 ILboolean ilIsValidBmpF(ILHANDLE File);

 ILboolean ilIsValidBmpL(const void *Lump, ILuint Size);

--- src-IL/src/il_exr.cpp	2009-03-08 03:10:09.000000000 -0400

+++ src-IL/src/il_exr.cpp	2014-12-20 01:15:55.000000000 -0500

@@ -11,5 +11,5 @@

 //-----------------------------------------------------------------------------

-

+#include <machine/endian.h>

 #include "il_internal.h"

 #ifndef IL_NO_EXR

@@ -246,5 +246,5 @@

 		in.readPixels (dataWindow.min.y, dataWindow.max.y);

     }

-    catch (const exception &e)

+    catch (const exception)

     {

 	// If some of the pixels in the file cannot be read,

@@ -252,5 +252,4 @@

 	// to the caller.

 		ilSetError(IL_LIB_EXR_ERROR);  // Could I use something a bit more descriptive based on e?

-		e;  // Prevent the compiler from yelling at us about this being unused.

 		return IL_FALSE;

     }

--- src-IL/include/il_endian.h	2009-03-08 03:10:08.000000000 -0400

+++ src-IL/include/il_endian.h	2014-12-20 01:28:47.000000000 -0500

@@ -15,14 +15,7 @@

 #include "il_internal.h"

+#include <machine/endian.h>

-#ifdef WORDS_BIGENDIAN  // This is defined by ./configure.

-	#ifndef __BIG_ENDIAN__

-	#define __BIG_ENDIAN__ 1

-	#endif

-#endif

-

-#if (defined(__BYTE_ORDER__) && __BYTE_ORDER__ == __BIG_ENDIAN__) \

-  || (defined(__BIG_ENDIAN__) && !defined(__LITTLE_ENDIAN__))

- 	#undef __LITTLE_ENDIAN__

+#if BYTE_ORDER == BIG_ENDIAN

 	#define Short(s) iSwapShort(s)

 	#define UShort(s) iSwapUShort(s)

@@ -39,7 +32,4 @@

 	#define BigDouble(d)  

 #else

-	#undef __BIG_ENDIAN__

-	#undef __LITTLE_ENDIAN__  // Not sure if it's defined by any compiler...

-	#define __LITTLE_ENDIAN__

 	#define Short(s)  

 	#define UShort(s)  

@@ -168,5 +158,5 @@

 	ILushort s;

 	iread(&s, sizeof(ILushort), 1);

-#ifdef __BIG_ENDIAN__

+#if BYTE_ORDER == BIG_ENDIAN

 	iSwapUShort(&s);

 #endif

@@ -177,5 +167,5 @@

 	ILshort s;

 	iread(&s, sizeof(ILshort), 1);

-#ifdef __BIG_ENDIAN__

+#if BYTE_ORDER == BIG_ENDIAN

 	iSwapShort(&s);

 #endif

@@ -186,5 +176,5 @@

 	ILuint i;

 	iread(&i, sizeof(ILuint), 1);

-#ifdef __BIG_ENDIAN__

+#if BYTE_ORDER == BIG_ENDIAN

 	iSwapUInt(&i);

 #endif

@@ -195,5 +185,5 @@

 	ILint i;

 	iread(&i, sizeof(ILint), 1);

-#ifdef __BIG_ENDIAN__

+#if BYTE_ORDER == BIG_ENDIAN

 	iSwapInt(&i);

 #endif

@@ -204,5 +194,5 @@

 	ILfloat f;

 	iread(&f, sizeof(ILfloat), 1);

-#ifdef __BIG_ENDIAN__

+#if BYTE_ORDER == BIG_ENDIAN

 	iSwapFloat(&f);

 #endif

@@ -213,5 +203,5 @@

 	ILdouble d;

 	iread(&d, sizeof(ILdouble), 1);

-#ifdef __BIG_ENDIAN__

+#if BYTE_ORDER == BIG_ENDIAN

 	iSwapDouble(&d);

 #endif

@@ -223,5 +213,5 @@

 	ILushort s;

 	iread(&s, sizeof(ILushort), 1);

-#ifdef __LITTLE_ENDIAN__

+#if BYTE_ORDER == LITTLE_ENDIAN

 	iSwapUShort(&s);

 #endif

@@ -233,5 +223,5 @@

 	ILshort s;

 	iread(&s, sizeof(ILshort), 1);

-#ifdef __LITTLE_ENDIAN__

+#if BYTE_ORDER == LITTLE_ENDIAN

 	iSwapShort(&s);

 #endif

@@ -243,5 +233,5 @@

 	ILuint i;

 	iread(&i, sizeof(ILuint), 1);

-#ifdef __LITTLE_ENDIAN__

+#if BYTE_ORDER == LITTLE_ENDIAN

 	iSwapUInt(&i);

 #endif

@@ -253,5 +243,5 @@

 	ILint i;

 	iread(&i, sizeof(ILint), 1);

-#ifdef __LITTLE_ENDIAN__

+#if BYTE_ORDER == LITTLE_ENDIAN

 	iSwapInt(&i);

 #endif

@@ -263,5 +253,5 @@

 	ILfloat f;

 	iread(&f, sizeof(ILfloat), 1);

-#ifdef __LITTLE_ENDIAN__

+#if BYTE_ORDER == LITTLE_ENDIAN

 	iSwapFloat(&f);

 #endif

@@ -273,5 +263,5 @@

 	ILdouble d;

 	iread(&d, sizeof(ILdouble), 1);

-#ifdef __LITTLE_ENDIAN__

+#if BYTE_ORDER == LITTLE_ENDIAN

 	iSwapDouble(&d);

 #endif

@@ -280,5 +270,5 @@

 INLINE ILubyte SaveLittleUShort(ILushort s) {

-#ifdef __BIG_ENDIAN__

+#if BYTE_ORDER == BIG_ENDIAN

 	iSwapUShort(&s);

 #endif

@@ -287,5 +277,5 @@

 INLINE ILubyte SaveLittleShort(ILshort s) {

-#ifdef __BIG_ENDIAN__

+#if BYTE_ORDER == BIG_ENDIAN

 	iSwapShort(&s);

 #endif

@@ -295,5 +285,5 @@

 INLINE ILubyte SaveLittleUInt(ILuint i) {

-#ifdef __BIG_ENDIAN__

+#if BYTE_ORDER == BIG_ENDIAN

 	iSwapUInt(&i);

 #endif

@@ -303,5 +293,5 @@

 INLINE ILubyte SaveLittleInt(ILint i) {

-#ifdef __BIG_ENDIAN__

+#if BYTE_ORDER == BIG_ENDIAN

 	iSwapInt(&i);

 #endif

@@ -310,5 +300,5 @@

 INLINE ILubyte SaveLittleFloat(ILfloat f) {

-#ifdef __BIG_ENDIAN__

+#if BYTE_ORDER == BIG_ENDIAN

 	iSwapFloat(&f);

 #endif

@@ -318,5 +308,5 @@

 INLINE ILubyte SaveLittleDouble(ILdouble d) {

-#ifdef __BIG_ENDIAN__

+#if BYTE_ORDER == BIG_ENDIAN

 	iSwapDouble(&d);

 #endif

@@ -326,5 +316,5 @@

 INLINE ILubyte SaveBigUShort(ILushort s) {

-#ifdef __LITTLE_ENDIAN__

+#if BYTE_ORDER == LITTLE_ENDIAN

 	iSwapUShort(&s);

 #endif

@@ -334,5 +324,5 @@

 INLINE ILubyte SaveBigShort(ILshort s) {

-#ifdef __LITTLE_ENDIAN__

+#if BYTE_ORDER == LITTLE_ENDIAN

 	iSwapShort(&s);

 #endif

@@ -342,5 +332,5 @@

 INLINE ILubyte SaveBigUInt(ILuint i) {

-#ifdef __LITTLE_ENDIAN__

+#if BYTE_ORDER == LITTLE_ENDIAN

 	iSwapUInt(&i);

 #endif

@@ -350,5 +340,5 @@

 INLINE ILubyte SaveBigInt(ILint i) {

-#ifdef __LITTLE_ENDIAN__

+#if BYTE_ORDER == LITTLE_ENDIAN

 	iSwapInt(&i);

 #endif

@@ -358,5 +348,5 @@

 INLINE ILubyte SaveBigFloat(ILfloat f) {

-#ifdef __LITTLE_ENDIAN__

+#if BYTE_ORDER == LITTLE_ENDIAN

 	iSwapFloat(&f);

 #endif

@@ -366,5 +356,5 @@

 INLINE ILubyte SaveBigDouble(ILdouble d) {

-#ifdef __LITTLE_ENDIAN__

+#if BYTE_ORDER == LITTLE_ENDIAN

 	iSwapDouble(&d);

 #endif

--- ./src-IL/src/il_convert.c	2009-03-08 03:10:09.000000000 -0400

+++ ./src-IL/src/il_convert.c	2014-12-20 01:36:37.000000000 -0500

@@ -1018,5 +1018,5 @@

 	}

 /*	Swap Colors on Big Endian !!!!!

-#ifdef __BIG_ENDIAN__

+#if BYTE_ORDER == BIG_ENDIAN

 	// Swap endian

 	EndianSwapData(iCurImage);

--- ./src-IL/src/il_dicom.c	2009-03-08 03:10:09.000000000 -0400

+++ ./src-IL/src/il_dicom.c	2014-12-20 01:36:37.000000000 -0500

@@ -536,5 +536,5 @@

 	// We may have to swap the order of the data.

-#ifdef __BIG_ENDIAN__

+#if BYTE_ORDER == BIG_ENDIAN

 			if (!Header.BigEndian) {

 				if (Header.Format == IL_RGB)

--- ./src-IL/src/il_icon.c	2014-12-20 01:00:18.000000000 -0500

+++ ./src-IL/src/il_icon.c	2014-12-20 01:36:37.000000000 -0500

@@ -555,5 +555,5 @@

 	//fix endianess

-#ifdef __LITTLE_ENDIAN__

+#if BYTE_ORDER == LITTLE_ENDIAN

 	if (bit_depth == 16)

 		png_set_swap(ico_png_ptr);

--- ./src-IL/src/il_png.c	2014-12-20 01:00:18.000000000 -0500

+++ ./src-IL/src/il_png.c	2014-12-20 01:36:37.000000000 -0500

@@ -308,5 +308,5 @@

 	//fix endianess

-#ifdef __LITTLE_ENDIAN__

+#if BYTE_ORDER == LITTLE_ENDIAN

 	if (bit_depth == 16)

 		png_set_swap(png_ptr);

--- ./src-IL/src/il_psd.c	2009-03-08 03:10:09.000000000 -0400

+++ ./src-IL/src/il_psd.c	2014-12-20 01:36:37.000000000 -0500

@@ -542,5 +542,5 @@

 		return NULL;

 	}

-#ifdef __LITTLE_ENDIAN__

+#if BYTE_ORDER == LITTLE_ENDIAN

 	for (i = 0; i < Head->Height * ChannelNum; i++) {

 		iSwapUShort(&RleTable[i]);

--- ./src-IL/src/il_tiff.c	2009-03-08 03:10:09.000000000 -0400

+++ ./src-IL/src/il_tiff.c	2014-12-20 01:36:37.000000000 -0500

@@ -611,5 +611,5 @@

 			Image->Origin = IL_ORIGIN_LOWER_LEFT;  // eiu...dunno if this is right

-#ifdef __BIG_ENDIAN__ //TIFFReadRGBAImage reads abgr on big endian, convert to rgba

+#if BYTE_ORDER == BIG_ENDIAN //TIFFReadRGBAImage reads abgr on big endian, convert to rgba

 			EndianSwapData(Image);

 #endif

@@ -636,5 +636,5 @@

 				case 3:

 					//TODO: why the ifdef??

-#ifdef __LITTLE_ENDIAN__

+#if BYTE_ORDER == LITTLE_ENDIAN

 					ilConvertImage(IL_RGB, IL_UNSIGNED_BYTE);

 #endif			

@@ -647,5 +647,5 @@

 					/*			

 					//invert alpha

-#ifdef __LITTLE_ENDIAN__

+#if BYTE_ORDER == LITTLE_ENDIAN

 					pImageData += 3;

 #endif			

--- ./src-ILUT/src/ilut_sdlsurface.c	2009-03-08 03:10:11.000000000 -0400

+++ ./src-ILUT/src/ilut_sdlsurface.c	2014-12-20 01:36:37.000000000 -0500

@@ -28,5 +28,5 @@

 {

 //#if SDL_BYTEORDER == SDL_BIG_ENDIAN

-#ifdef __BIG_ENDIAN__

+#if BYTE_ORDER == BIG_ENDIAN

 	isBigEndian = 1;

     rmask = 0xFF000000;

@@ -81,5 +81,5 @@

 	}

 	else if (Image->Format != IL_COLOR_INDEX) {  // We have to convert the image.

-		#ifdef __BIG_ENDIAN__

+		#if BYTE_ORDER == BIG_ENDIAN

 		Image = iConvertImage(Image, IL_RGBA, IL_UNSIGNED_BYTE);

 		#else

--- src-IL/src/il_ilbm.c	2009-03-08 04:30:11.000000000 -0400

+++ src-IL/src/il_ilbm.c	2014-12-20 01:38:51.000000000 -0500

@@ -620,5 +620,5 @@

                             finalcolor = pixelcolor;

                         }

-#if defined( __LITTLE_ENDIAN__ )

+#if BYTE_ORDER == LITTLE_ENDIAN

                         {

                             *ptr++ = (Uint8)(finalcolor>>16);

--- src-IL/src/il_sgi.c	2009-03-08 03:10:09.000000000 -0400

+++ src-IL/src/il_sgi.c	2014-12-20 01:40:37.000000000 -0500

@@ -213,5 +213,5 @@

 ILboolean iReadRleSgi(iSgiHeader *Head)

 {

-	#ifdef __LITTLE_ENDIAN__

+	#if BYTE_ORDER == LITTLE_ENDIAN

 	ILuint ixTable;

 	#endif

@@ -234,5 +234,5 @@

 		goto cleanup_error;

-#ifdef __LITTLE_ENDIAN__

+#if BYTE_ORDER == LITTLE_ENDIAN

 	// Fix the offset/len table (it's big endian format)

 	for (ixTable = 0; ixTable < TableSize; ixTable++) {

@@ -290,5 +290,5 @@

 	}

-	#ifdef __LITTLE_ENDIAN__

+	#if BYTE_ORDER == LITTLE_ENDIAN

 	if (Head->Bpc == 2)

 		sgiSwitchData(iCurImage->Data, iCurImage->SizeOfData);

@@ -331,5 +331,5 @@

 			return -1;

-#ifndef __LITTLE_ENDIAN__

+#if BYTE_ORDER != LITTLE_ENDIAN

 		iSwapUShort(&Pixel);

 #endif

@@ -347,5 +347,5 @@

 			if (iread(&Pixel, Head->Bpc, 1) != 1)

 				return -1;

-#ifndef __LITTLE_ENDIAN__

+#if BYTE_ORDER != LITTLE_ENDIAN

 			iSwapUShort(&Pixel);

 #endif

@@ -742,5 +742,5 @@

 		StartTable[y] = DataOff;

 		DataOff += LenTable[y];

-#ifdef __LITTLE_ENDIAN__

+#if BYTE_ORDER == LITTLE_ENDIAN

 		iSwapUInt(&StartTable[y]);

  		iSwapUInt(&LenTable[y]);

Submitted upstream as https://sourceforge.net/p/openil/patches/53/

Fix to allow running with regular shell. Actually, even bash was erroring

out for some reason...

--- test/format_test/format_checks.sh.in	2009-03-08 03:10:07.000000000 -0400

+++ test/format_test/format_checks.sh.in	2016-01-10 23:37:45.922896000 -0500

@@ -27,8 +27,17 @@

 do

 	#echo expr match "' $CAN_SAVE '" '.*\s'$EXTENSION'\s.*'

-	if [ $(expr match "' $CAN_SAVE '" '.*\s'$EXTENSION'\s.*') -eq 0 -o $(expr match "' $PROBLEMATIC '" '.*\s'$EXTENSION'\s.*') -ne 0 ] 

-	then # This extension is not considered as supported...

-		continue;

-	fi

+	case $CAN_SAVE in

+	*$EXTENSION*)

+		;;

+	*)

+		# This extension is not considered as supported...

+		continue

+		;;

+	esac

+	case $PROBLEMATIC in

+	*$EXTENSION*)

+		continue

+		;;

+	esac	

 	test -n	"$VERBOSE" && echo $WINE ./testil@EXEEXT@ -e $EXTENSION

 	# EXEEXT comes in when one compiles on platforms that append extensions to executables (testil.exe)