files/Source/FreeImage/PluginSGI.cpp - free_image - Git at Google

 // ==========================================================
 // SGI Loader
 //
 // Design and implementation by
 // - Sherman Wilcox
 // - Noam Gat
 //
 // References :
 // ------------
 // - The SGI Image File Format, Version 1.0
 // http://astronomy.swin.edu.au/~pbourke/dataformats/sgirgb/sgiversion.html
 // - SGI RGB Image Format
 // http://astronomy.swin.edu.au/~pbourke/dataformats/sgirgb/
 //
 //
 // This file is part of FreeImage 3
 //
 // COVERED CODE IS PROVIDED UNDER THIS LICENSE ON AN "AS IS" BASIS, WITHOUT WARRANTY
 // OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, WITHOUT LIMITATION, WARRANTIES
 // THAT THE COVERED CODE IS FREE OF DEFECTS, MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE
 // OR NON-INFRINGING. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE COVERED
 // CODE IS WITH YOU. SHOULD ANY COVERED CODE PROVE DEFECTIVE IN ANY RESPECT, YOU (NOT
 // THE INITIAL DEVELOPER OR ANY OTHER CONTRIBUTOR) ASSUME THE COST OF ANY NECESSARY
 // SERVICING, REPAIR OR CORRECTION. THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL
 // PART OF THIS LICENSE. NO USE OF ANY COVERED CODE IS AUTHORIZED HEREUNDER EXCEPT UNDER
 // THIS DISCLAIMER.
 //
 // Use at your own risk!
 // ==========================================================

 #include "FreeImage.h"
 #include "Utilities.h"

 // ----------------------------------------------------------
 //   Constants + headers
 // ----------------------------------------------------------

 #ifdef _WIN32
 #pragma pack(push, 1)
 #else
 #pragma pack(1)
 #endif

 typedef struct tagSGIHeader {
 	/** IRIS image file magic number. This should be decimal 474. */
 	WORD magic;
 	/** Storage format: 0 for uncompressed, 1 for RLE compression. */
 	BYTE storage;
 	/** Number of bytes per pixel channel. Legally 1 or 2. */
 	BYTE bpc;
 	/**
 	Number of dimensions. Legally 1, 2, or 3.
 	1 means a single row, XSIZE long
 	2 means a single 2D image
 	3 means multiple 2D images
 	*/
 	WORD dimension;
 	/** X size in pixels */
 	WORD xsize;
 	/** Y size in pixels */
 	WORD ysize;
 	/**
 	Number of channels.
 	1 indicates greyscale
 	3 indicates RGB
 	4 indicates RGB and Alpha
 	*/
 	WORD zsize;
 	/** Minimum pixel value. This is the lowest pixel value in the image.*/
 	LONG pixmin;
 	/** Maximum pixel value. This is the highest pixel value in the image.*/
 	LONG pixmax;
 	/** Ignored. Normally set to 0. */
 	char dummy[4];
 	/** Image name. Must be null terminated, therefore at most 79 bytes. */
 	char imagename[80];
 	/**
 	Colormap ID.
 	0 - normal mode
 	1 - dithered, 3 mits for red and green, 2 for blue, obsolete
 	2 - index colour, obsolete
 	3 - not an image but a colourmap
 	*/
 	LONG colormap;
 	/** Ignored. Should be set to 0, makes the header 512 bytes. */
 	char reserved[404];
 } SGIHeader;

 typedef struct tagRLEStatus {
   int cnt;
   int val;
 } RLEStatus;

 #ifdef _WIN32
 #pragma pack(pop)
 #else
 #pragma pack()
 #endif

 static const char *SGI_LESS_THAN_HEADER_LENGTH = "Incorrect header size";
 static const char *SGI_16_BIT_COMPONENTS_NOT_SUPPORTED = "No 16 bit support";
 static const char *SGI_COLORMAPS_NOT_SUPPORTED = "No colormap support";
 static const char *SGI_EOF_IN_RLE_INDEX = "EOF in run length encoding";
 static const char *SGI_EOF_IN_IMAGE_DATA = "EOF in image data";
 static const char *SGI_INVALID_CHANNEL_COUNT = "Invalid channel count";

 // ==========================================================
 // Plugin Interface
 // ==========================================================

 static int s_format_id;

 // ==========================================================
 // Plugin Implementation
 // ==========================================================

 #ifndef FREEIMAGE_BIGENDIAN
 static void
 SwapHeader(SGIHeader *header) {
 	SwapShort(&header->magic);
 	SwapShort(&header->dimension);
 	SwapShort(&header->xsize);
 	SwapShort(&header->ysize);
 	SwapShort(&header->zsize);
 	SwapLong((DWORD*)&header->pixmin);
 	SwapLong((DWORD*)&header->pixmax);
 	SwapLong((DWORD*)&header->colormap);
 }
 #endif

 static int
 get_rlechar(FreeImageIO *io, fi_handle handle, RLEStatus *pstatus) {
 	if (!pstatus->cnt) {
 		int cnt = 0;
 		while (0 == cnt) {
 			BYTE packed = 0;
 			if(io->read_proc(&packed, sizeof(BYTE), 1, handle) < 1) {
 				return EOF;
 			}
 			cnt = packed;
 		}
 		if (cnt == EOF) {
 			return EOF;
 		}
 		pstatus->cnt = cnt & 0x7F;
 		if (cnt & 0x80) {
 			pstatus->val = -1;
 		} else {
 			BYTE packed = 0;
 			if(io->read_proc(&packed, sizeof(BYTE), 1, handle) < 1) {
 				return EOF;
 			}
 			pstatus->val = packed;
 		}
 	}
 	pstatus->cnt--;
 	if (pstatus->val == -1) {
 		BYTE packed = 0;
 		if(io->read_proc(&packed, sizeof(BYTE), 1, handle) < 1) {
 			return EOF;
 		}
 		return packed;
 	}
 	else {
 		return pstatus->val;
 	}
 }

 static const char * DLL_CALLCONV
 Format() {
   return "SGI";
 }

 static const char * DLL_CALLCONV
 Description() {
   return "SGI Image Format";
 }

 static const char * DLL_CALLCONV
 Extension() {
   return "sgi,rgb,rgba,bw";
 }

 static const char * DLL_CALLCONV
 RegExpr() {
   return NULL;
 }

 static const char * DLL_CALLCONV
 MimeType() {
   return "image/x-sgi";
 }

 static BOOL DLL_CALLCONV
 Validate(FreeImageIO *io, fi_handle handle) {
 	BYTE sgi_signature[2] = { 0x01, 0xDA };
 	BYTE signature[2] = { 0, 0 };

 	io->read_proc(signature, 1, sizeof(sgi_signature), handle);

 	return (memcmp(sgi_signature, signature, sizeof(sgi_signature)) == 0);
 }

 static BOOL DLL_CALLCONV
 SupportsExportDepth(int depth) {
   return FALSE;
 }

 static BOOL DLL_CALLCONV
 SupportsExportType(FREE_IMAGE_TYPE type) {
   return FALSE;
 }

 static FIBITMAP * DLL_CALLCONV
 Load(FreeImageIO *io, fi_handle handle, int page, int flags, void *data) {
 	int width = 0, height = 0, zsize = 0;
 	int i, dim;
 	int bitcount;
 	SGIHeader sgiHeader;
 	RLEStatus my_rle_status;
 	FIBITMAP *dib = NULL;
 	LONG *pRowIndex = NULL;

 	try {
 		// read the header
 		memset(&sgiHeader, 0, sizeof(SGIHeader));
 		if(io->read_proc(&sgiHeader, 1, sizeof(SGIHeader), handle) < sizeof(SGIHeader)) {
 		   throw SGI_LESS_THAN_HEADER_LENGTH;
 		}
 #ifndef FREEIMAGE_BIGENDIAN
 		SwapHeader(&sgiHeader);
 #endif
 		if(sgiHeader.magic != 474) {
 			throw FI_MSG_ERROR_MAGIC_NUMBER;
 		}

 		BOOL bIsRLE = (sgiHeader.storage == 1) ? TRUE : FALSE;

 		// check for unsupported image types
 		if (sgiHeader.bpc != 1) {
 			// Expected one byte per color component
 			throw SGI_16_BIT_COMPONENTS_NOT_SUPPORTED;
 		}
 		if (sgiHeader.colormap != 0) {
 			// Indexed or dithered images not supported
 			throw SGI_COLORMAPS_NOT_SUPPORTED;
 		}

 		// get the width & height
 		dim = sgiHeader.dimension;
 		width = sgiHeader.xsize;
 		if (dim < 3) {
 			zsize = 1;
 		} else {
 			zsize = sgiHeader.zsize;
 		}

 		if (dim < 2) {
 			height = 1;
 		} else {
 			height = sgiHeader.ysize;
 		}

 		if(bIsRLE) {
 			// read the Offset Tables
 			int index_len = height * zsize;
 			pRowIndex = (LONG*)malloc(index_len * sizeof(LONG));
 			if(!pRowIndex) {
 				throw FI_MSG_ERROR_MEMORY;
 			}

 			if ((unsigned)index_len != io->read_proc(pRowIndex, sizeof(LONG), index_len, handle)) {
 				throw SGI_EOF_IN_RLE_INDEX;
 			}

 #ifndef FREEIMAGE_BIGENDIAN
 			// Fix byte order in index
 			for (i = 0; i < index_len; i++) {
 				SwapLong((DWORD*)&pRowIndex[i]);
 			}
 #endif
 			// Discard row size index
 			for (i = 0; i < (int)(index_len * sizeof(LONG)); i++) {
 				BYTE packed = 0;
 				if( io->read_proc(&packed, sizeof(BYTE), 1, handle) < 1 ) {
 					throw SGI_EOF_IN_RLE_INDEX;
 				}
 			}
 		}

 		switch(zsize) {
 			case 1:
 				bitcount = 8;
 				break;
 			case 2:
 				//Grayscale+Alpha. Need to fake RGBA
 				bitcount = 32;
 				break;
 			case 3:
 				bitcount = 24;
 				break;
 			case 4:
 				bitcount = 32;
 				break;
 			default:
 				throw SGI_INVALID_CHANNEL_COUNT;
 		}

 		dib = FreeImage_Allocate(width, height, bitcount);
 		if(!dib) {
 			throw FI_MSG_ERROR_DIB_MEMORY;
 		}

 		if (bitcount == 8) {
 			// 8-bit SGI files are grayscale images, so we'll generate
 			// a grayscale palette.
 			RGBQUAD *pclrs = FreeImage_GetPalette(dib);
 			for (i = 0; i < 256; i++) {
 				pclrs[i].rgbRed = (BYTE)i;
 				pclrs[i].rgbGreen = (BYTE)i;
 				pclrs[i].rgbBlue = (BYTE)i;
 				pclrs[i].rgbReserved = 0;
 			}
 		}

 		// decode the image

 		memset(&my_rle_status, 0, sizeof(RLEStatus));

 		int ns = FreeImage_GetPitch(dib);
 		BYTE *pStartRow = FreeImage_GetScanLine(dib, 0);
 		int offset_table[] = { 2, 1, 0, 3 };
 		int numChannels = zsize;
 		if (zsize < 3) {
 			offset_table[0] = 0;
 		}
 		if (zsize == 2)
 		{
 			//This is how faked grayscale+alpha works.
 			//First channel goes into first
 			//second channel goes into alpha (4th channel)
 			//Two channels are left empty and will be copied later
 			offset_table[1] = 3;
 			numChannels = 4;
 		}

 		LONG *pri = pRowIndex;
 		for (i = 0; i < zsize; i++) {
 			BYTE *pRow = pStartRow + offset_table[i];
 			for (int j = 0; j < height; j++, pRow += ns, pri++) {
 				BYTE *p = pRow;
 				if (bIsRLE) {
 					my_rle_status.cnt = 0;
 					io->seek_proc(handle, *pri, SEEK_SET);
 				}
 				for (int k = 0; k < width; k++, p += numChannels) {
 					int ch;
 					BYTE packed = 0;
 					if (bIsRLE) {
 						ch = get_rlechar(io, handle, &my_rle_status);
 						packed = (BYTE)ch;
 					}
 					else {
 						ch = io->read_proc(&packed, sizeof(BYTE), 1, handle);
 					}
 					if (ch == EOF) {
 						throw SGI_EOF_IN_IMAGE_DATA;
 					}
 					*p = packed;
 				}
 			}
 		}

 		if (zsize == 2)
 		{
 			BYTE *pRow = pStartRow;
 			//If faking RGBA from grayscale + alpha, copy first channel to second and third
 			for (int i=0; i<height; i++, pRow += ns)
 			{
 				BYTE *pPixel = pRow;
 				for (int j=0; j<width; j++)
 				{
 					pPixel[2] = pPixel[1] = pPixel[0];
 					pPixel += 4;
 				}
 			}
 		}
 		if(pRowIndex)
 			free(pRowIndex);

 		return dib;

 	} catch(const char *text) {
 		if(pRowIndex) free(pRowIndex);
 		if(dib) FreeImage_Unload(dib);
 		FreeImage_OutputMessageProc(s_format_id, text);
 		return NULL;
 	}
 }

 // ==========================================================
 //   Init
 // ==========================================================

 void DLL_CALLCONV
 InitSGI(Plugin *plugin, int format_id) {
 	s_format_id = format_id;

 	plugin->format_proc = Format;
 	plugin->description_proc = Description;
 	plugin->extension_proc = Extension;
 	plugin->regexpr_proc = RegExpr;
 	plugin->open_proc = NULL;
 	plugin->close_proc = NULL;
 	plugin->pagecount_proc = NULL;
 	plugin->pagecapability_proc = NULL;
 	plugin->load_proc = Load;
 	plugin->save_proc = NULL;
 	plugin->validate_proc = Validate;
 	plugin->mime_proc = MimeType;
 	plugin->supports_export_bpp_proc = SupportsExportDepth;
 	plugin->supports_export_type_proc = SupportsExportType;
 	plugin->supports_icc_profiles_proc = NULL;
 }
	// ==========================================================
	// SGI Loader
	//
	// Design and implementation by
	// - Sherman Wilcox
	// - Noam Gat
	//
	// References :
	// ------------
	// - The SGI Image File Format, Version 1.0
	// http://astronomy.swin.edu.au/~pbourke/dataformats/sgirgb/sgiversion.html
	// - SGI RGB Image Format
	// http://astronomy.swin.edu.au/~pbourke/dataformats/sgirgb/
	//
	//
	// This file is part of FreeImage 3
	//
	// COVERED CODE IS PROVIDED UNDER THIS LICENSE ON AN "AS IS" BASIS, WITHOUT WARRANTY
	// OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, WITHOUT LIMITATION, WARRANTIES
	// THAT THE COVERED CODE IS FREE OF DEFECTS, MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE
	// OR NON-INFRINGING. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE COVERED
	// CODE IS WITH YOU. SHOULD ANY COVERED CODE PROVE DEFECTIVE IN ANY RESPECT, YOU (NOT
	// THE INITIAL DEVELOPER OR ANY OTHER CONTRIBUTOR) ASSUME THE COST OF ANY NECESSARY
	// SERVICING, REPAIR OR CORRECTION. THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL
	// PART OF THIS LICENSE. NO USE OF ANY COVERED CODE IS AUTHORIZED HEREUNDER EXCEPT UNDER
	// THIS DISCLAIMER.
	//
	// Use at your own risk!
	// ==========================================================

	#include "FreeImage.h"
	#include "Utilities.h"

	// ----------------------------------------------------------
	// Constants + headers
	// ----------------------------------------------------------

	#ifdef _WIN32
	#pragma pack(push, 1)
	#else
	#pragma pack(1)
	#endif

	typedef struct tagSGIHeader {
	/** IRIS image file magic number. This should be decimal 474. */
	WORD magic;
	/** Storage format: 0 for uncompressed, 1 for RLE compression. */
	BYTE storage;
	/** Number of bytes per pixel channel. Legally 1 or 2. */
	BYTE bpc;
	/**
	Number of dimensions. Legally 1, 2, or 3.
	1 means a single row, XSIZE long
	2 means a single 2D image
	3 means multiple 2D images
	*/
	WORD dimension;
	/** X size in pixels */
	WORD xsize;
	/** Y size in pixels */
	WORD ysize;
	/**
	Number of channels.
	1 indicates greyscale
	3 indicates RGB
	4 indicates RGB and Alpha
	*/
	WORD zsize;
	/** Minimum pixel value. This is the lowest pixel value in the image.*/
	LONG pixmin;
	/** Maximum pixel value. This is the highest pixel value in the image.*/
	LONG pixmax;
	/** Ignored. Normally set to 0. */
	char dummy[4];
	/** Image name. Must be null terminated, therefore at most 79 bytes. */
	char imagename[80];
	/**
	Colormap ID.
	0 - normal mode
	1 - dithered, 3 mits for red and green, 2 for blue, obsolete
	2 - index colour, obsolete
	3 - not an image but a colourmap
	*/
	LONG colormap;
	/** Ignored. Should be set to 0, makes the header 512 bytes. */
	char reserved[404];
	} SGIHeader;

	typedef struct tagRLEStatus {
	int cnt;
	int val;
	} RLEStatus;

	#ifdef _WIN32
	#pragma pack(pop)
	#else
	#pragma pack()
	#endif

	static const char *SGI_LESS_THAN_HEADER_LENGTH = "Incorrect header size";
	static const char *SGI_16_BIT_COMPONENTS_NOT_SUPPORTED = "No 16 bit support";
	static const char *SGI_COLORMAPS_NOT_SUPPORTED = "No colormap support";
	static const char *SGI_EOF_IN_RLE_INDEX = "EOF in run length encoding";
	static const char *SGI_EOF_IN_IMAGE_DATA = "EOF in image data";
	static const char *SGI_INVALID_CHANNEL_COUNT = "Invalid channel count";

	// ==========================================================
	// Plugin Interface
	// ==========================================================

	static int s_format_id;

	// ==========================================================
	// Plugin Implementation
	// ==========================================================

	#ifndef FREEIMAGE_BIGENDIAN
	static void
	SwapHeader(SGIHeader *header) {
	SwapShort(&header->magic);
	SwapShort(&header->dimension);
	SwapShort(&header->xsize);
	SwapShort(&header->ysize);
	SwapShort(&header->zsize);
	SwapLong((DWORD*)&header->pixmin);
	SwapLong((DWORD*)&header->pixmax);
	SwapLong((DWORD*)&header->colormap);
	}
	#endif

	static int
	get_rlechar(FreeImageIO io, fi_handle handle, RLEStatus pstatus) {
	if (!pstatus->cnt) {
	int cnt = 0;
	while (0 == cnt) {
	BYTE packed = 0;
	if(io->read_proc(&packed, sizeof(BYTE), 1, handle) < 1) {
	return EOF;
	}
	cnt = packed;
	}
	if (cnt == EOF) {
	return EOF;
	}
	pstatus->cnt = cnt & 0x7F;
	if (cnt & 0x80) {
	pstatus->val = -1;
	} else {
	BYTE packed = 0;
	if(io->read_proc(&packed, sizeof(BYTE), 1, handle) < 1) {
	return EOF;
	}
	pstatus->val = packed;
	}
	}
	pstatus->cnt--;
	if (pstatus->val == -1) {
	BYTE packed = 0;
	if(io->read_proc(&packed, sizeof(BYTE), 1, handle) < 1) {
	return EOF;
	}
	return packed;
	}
	else {
	return pstatus->val;
	}
	}

	static const char * DLL_CALLCONV
	Format() {
	return "SGI";
	}

	static const char * DLL_CALLCONV
	Description() {
	return "SGI Image Format";
	}

	static const char * DLL_CALLCONV
	Extension() {
	return "sgi,rgb,rgba,bw";
	}

	static const char * DLL_CALLCONV
	RegExpr() {
	return NULL;
	}

	static const char * DLL_CALLCONV
	MimeType() {
	return "image/x-sgi";
	}

	static BOOL DLL_CALLCONV
	Validate(FreeImageIO *io, fi_handle handle) {
	BYTE sgi_signature[2] = { 0x01, 0xDA };
	BYTE signature[2] = { 0, 0 };

	io->read_proc(signature, 1, sizeof(sgi_signature), handle);

	return (memcmp(sgi_signature, signature, sizeof(sgi_signature)) == 0);
	}

	static BOOL DLL_CALLCONV
	SupportsExportDepth(int depth) {
	return FALSE;
	}

	static BOOL DLL_CALLCONV
	SupportsExportType(FREE_IMAGE_TYPE type) {
	return FALSE;
	}

	static FIBITMAP * DLL_CALLCONV
	Load(FreeImageIO io, fi_handle handle, int page, int flags, void data) {
	int width = 0, height = 0, zsize = 0;
	int i, dim;
	int bitcount;
	SGIHeader sgiHeader;
	RLEStatus my_rle_status;
	FIBITMAP *dib = NULL;
	LONG *pRowIndex = NULL;

	try {
	// read the header
	memset(&sgiHeader, 0, sizeof(SGIHeader));
	if(io->read_proc(&sgiHeader, 1, sizeof(SGIHeader), handle) < sizeof(SGIHeader)) {
	throw SGI_LESS_THAN_HEADER_LENGTH;
	}
	#ifndef FREEIMAGE_BIGENDIAN
	SwapHeader(&sgiHeader);
	#endif
	if(sgiHeader.magic != 474) {
	throw FI_MSG_ERROR_MAGIC_NUMBER;
	}

	BOOL bIsRLE = (sgiHeader.storage == 1) ? TRUE : FALSE;

	// check for unsupported image types
	if (sgiHeader.bpc != 1) {
	// Expected one byte per color component
	throw SGI_16_BIT_COMPONENTS_NOT_SUPPORTED;
	}
	if (sgiHeader.colormap != 0) {
	// Indexed or dithered images not supported
	throw SGI_COLORMAPS_NOT_SUPPORTED;
	}

	// get the width & height
	dim = sgiHeader.dimension;
	width = sgiHeader.xsize;
	if (dim < 3) {
	zsize = 1;
	} else {
	zsize = sgiHeader.zsize;
	}

	if (dim < 2) {
	height = 1;
	} else {
	height = sgiHeader.ysize;
	}

	if(bIsRLE) {
	// read the Offset Tables
	int index_len = height * zsize;
	pRowIndex = (LONG)malloc(index_len sizeof(LONG));
	if(!pRowIndex) {
	throw FI_MSG_ERROR_MEMORY;
	}

	if ((unsigned)index_len != io->read_proc(pRowIndex, sizeof(LONG), index_len, handle)) {
	throw SGI_EOF_IN_RLE_INDEX;
	}

	#ifndef FREEIMAGE_BIGENDIAN
	// Fix byte order in index
	for (i = 0; i < index_len; i++) {
	SwapLong((DWORD*)&pRowIndex[i]);
	}
	#endif
	// Discard row size index
	for (i = 0; i < (int)(index_len * sizeof(LONG)); i++) {
	BYTE packed = 0;
	if( io->read_proc(&packed, sizeof(BYTE), 1, handle) < 1 ) {
	throw SGI_EOF_IN_RLE_INDEX;
	}
	}
	}

	switch(zsize) {
	case 1:
	bitcount = 8;
	break;
	case 2:
	//Grayscale+Alpha. Need to fake RGBA
	bitcount = 32;
	break;
	case 3:
	bitcount = 24;
	break;
	case 4:
	bitcount = 32;
	break;
	default:
	throw SGI_INVALID_CHANNEL_COUNT;
	}

	dib = FreeImage_Allocate(width, height, bitcount);
	if(!dib) {
	throw FI_MSG_ERROR_DIB_MEMORY;
	}

	if (bitcount == 8) {
	// 8-bit SGI files are grayscale images, so we'll generate
	// a grayscale palette.
	RGBQUAD *pclrs = FreeImage_GetPalette(dib);
	for (i = 0; i < 256; i++) {
	pclrs[i].rgbRed = (BYTE)i;
	pclrs[i].rgbGreen = (BYTE)i;
	pclrs[i].rgbBlue = (BYTE)i;
	pclrs[i].rgbReserved = 0;
	}
	}

	// decode the image

	memset(&my_rle_status, 0, sizeof(RLEStatus));

	int ns = FreeImage_GetPitch(dib);
	BYTE *pStartRow = FreeImage_GetScanLine(dib, 0);
	int offset_table[] = { 2, 1, 0, 3 };
	int numChannels = zsize;
	if (zsize < 3) {
	offset_table[0] = 0;
	}
	if (zsize == 2)
	{
	//This is how faked grayscale+alpha works.
	//First channel goes into first
	//second channel goes into alpha (4th channel)
	//Two channels are left empty and will be copied later
	offset_table[1] = 3;
	numChannels = 4;
	}

	LONG *pri = pRowIndex;
	for (i = 0; i < zsize; i++) {
	BYTE *pRow = pStartRow + offset_table[i];
	for (int j = 0; j < height; j++, pRow += ns, pri++) {
	BYTE *p = pRow;
	if (bIsRLE) {
	my_rle_status.cnt = 0;
	io->seek_proc(handle, *pri, SEEK_SET);
	}
	for (int k = 0; k < width; k++, p += numChannels) {
	int ch;
	BYTE packed = 0;
	if (bIsRLE) {
	ch = get_rlechar(io, handle, &my_rle_status);
	packed = (BYTE)ch;
	}
	else {
	ch = io->read_proc(&packed, sizeof(BYTE), 1, handle);
	}
	if (ch == EOF) {
	throw SGI_EOF_IN_IMAGE_DATA;
	}
	*p = packed;
	}
	}
	}

	if (zsize == 2)
	{
	BYTE *pRow = pStartRow;
	//If faking RGBA from grayscale + alpha, copy first channel to second and third
	for (int i=0; i<height; i++, pRow += ns)
	{
	BYTE *pPixel = pRow;
	for (int j=0; j<width; j++)
	{
	pPixel[2] = pPixel[1] = pPixel[0];
	pPixel += 4;
	}
	}
	}
	if(pRowIndex)
	free(pRowIndex);

	return dib;

	} catch(const char *text) {
	if(pRowIndex) free(pRowIndex);
	if(dib) FreeImage_Unload(dib);
	FreeImage_OutputMessageProc(s_format_id, text);
	return NULL;
	}
	}

	// ==========================================================
	// Init
	// ==========================================================

	void DLL_CALLCONV
	InitSGI(Plugin *plugin, int format_id) {
	s_format_id = format_id;

	plugin->format_proc = Format;
	plugin->description_proc = Description;
	plugin->extension_proc = Extension;
	plugin->regexpr_proc = RegExpr;
	plugin->open_proc = NULL;
	plugin->close_proc = NULL;
	plugin->pagecount_proc = NULL;
	plugin->pagecapability_proc = NULL;
	plugin->load_proc = Load;
	plugin->save_proc = NULL;
	plugin->validate_proc = Validate;
	plugin->mime_proc = MimeType;
	plugin->supports_export_bpp_proc = SupportsExportDepth;
	plugin->supports_export_type_proc = SupportsExportType;
	plugin->supports_icc_profiles_proc = NULL;
	}