RedAlert/WIN32LIB/IFF/LOADPICT.CPP

/*
**	Command & Conquer Red Alert(tm)
**	Copyright 2025 Electronic Arts Inc.
**
**	This program is free software: you can redistribute it and/or modify
**	it under the terms of the GNU General Public License as published by
**	the Free Software Foundation, either version 3 of the License, or
**	(at your option) any later version.
**
**	This program is distributed in the hope that it will be useful,
**	but WITHOUT ANY WARRANTY; without even the implied warranty of
**	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
**	GNU General Public License for more details.
**
**	You should have received a copy of the GNU General Public License
**	along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/

/* $Header: g:/library/wwlib32/file/rcs/loadpict.cpp 1.1 1994/04/20 14:38:08 scott_bowen Exp $ */
/***************************************************************************
 **   C O N F I D E N T I A L --- W E S T W O O D   A S S O C I A T E S   **
 ***************************************************************************
 *                                                                         *
 *                 Project Name : Westwood Library                         *
 *                                                                         *
 *                    File Name : IFFEXTRA.C                               *
 *                                                                         *
 *                   Programmer : Joe L. Bostic                            *
 *                                                                         *
 *                   Start Date : June 11, 1991                            *
 *                                                                         *
 *                  Last Update : April 20, 1994   [SKB]                   *
 *                                                                         *
 *-------------------------------------------------------------------------*
 * Functions:                                                              *
 *   ILBM_To_Amiga -- Convert ILBM to bitplane Amiga format.               *
 *   ILBM_To_MCGA -- Converts ILBM picture into MCGA format.               *
 *   PBM_To_Amiga -- Converts a PBM picture into Amiga format.             *
 *   Load_Picture -- Loads a picture file (CPS or LBM format).             *
 * - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */

#include "iff.h"
#include "file.h"
#include <wwmem.h>	// For Alloc.

#if(IBM)
#include <mem.h>
#endif

// Since we are not currently using AMIGA, this has been put in to
// give us back some code space.  If it is needed for a utility,
// this module should be recompiled with that utility and set the
// define to TRUE.
#define	MAKE_AMIGA_ART	FALSE

/*
** An IFF picture file can have one of two formats:
**	ILBM	- InterLeaved Bit Map
**	PBM	- Packed Bit Map
*/
typedef enum {
	FORM_ILBM,
	FORM_PBM
} IFFForm_Type;

/*
**	These are the various chunks that compose an IFF picture file.
*/
#define ID_FORM			MAKE_ID('F','O','R','M')
#define ID_ILBM			MAKE_ID('I','L','B','M')
#define ID_PBM 			MAKE_ID('P','B','M',' ')
#define ID_CMAP 			MAKE_ID('C','M','A','P')
#define ID_BODY 			MAKE_ID('B','O','D','Y')
#define ID_BMHD 			MAKE_ID('B','M','H','D')


/*
**	The BMHD (Bit Map HeaDer) chunk in an IFF picture file contains the
**	information necessary to extract that picture from the BODY chunk.
**	It also indicates the size and depth of the source art.
*/
typedef struct {
	unsigned short	W, H;				// Raster width and height in pixels.
	short 	X, Y;						// Pixel postion for this image.
	char	BPlanes;						// Number of bitplanes.
	unsigned char	Masking;			// Masking control byte.
											// 0 = No masking.
											//	1 = Has a mask.
											//	2 = Has transparent color.
											//	3 = Lasso.
	unsigned char	Compression;	// Compression method.
											// 0 = No compression.
											// 1 = Byte run compression.
	char	pad;
	unsigned short	Transparent;	// Transparent color number.
	unsigned char	XAspect,			// Pixel aspect ratio of source art.
			YAspect;
	short	PageWidth, 					// Source 'page' size in pixels.
			PageHeight;
} BitMapHeader_Type;

/*=========================================================================*/
/* The following PRIVATE functions are in this file:                       */
/*=========================================================================*/

PRIVATE void __cdecl ILBM_To_MCGA(BufferClass& src, BufferClass& dest, int planes);
PRIVATE void __cdecl ILBM_To_Amiga(BufferClass& src, BufferClass& dest, int planes);
PRIVATE void __cdecl PBM_To_Amiga(BufferClass& src, BufferClass& dest, int planes);


/*= = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =*/



/***************************************************************************
 * ILBM_TO_MCGA -- Converts ILBM picture into MCGA format.                 *
 *                                                                         *
 *    This converts an ILBM picture (typical of DPaint LBM files) and      *
 *    converts it to MCGA mode (byte per pixel).  This function would be   *
 *    used after the body of an ILBM picture is loaded.  Because the       *
 *    number of bitplanes can vary greatly, it is necessary to pass the    *
 *    bitplane count to this function.  The size (320 by 200) of the       *
 *    source picture is presumed.                                          *
 *                                                                         *
 * INPUT:   src   - Buffer number for source ILBM picture.                 *
 *                                                                         *
 *          dest  - Buffer number for place to put MCGA format.            *
 *                                                                         *
 *          planes- The number of bitplanes in the ILBM picture.           *
 *                                                                         *
 * OUTPUT:     none                                                        *
 *                                                                         *
 * WARNINGS:   none                                                        *
 *                                                                         *
 * HISTORY:                                                                *
 *   05/16/1991 JLB : Created.                                             *
 *   04/20/1994 SKB : Update to 32 bit library and make private.           *
 *=========================================================================*/
PRIVATE void __cdecl ILBM_To_MCGA(BufferClass& src, BufferClass& dest, int planes)
{
	char	*source;			// Source pointer.
	char	*destination;	// Destination pointer.
	int	index,j,i;		// Working index values.
	int	bplane;			// Bit plane counter.
	char	bytes[8];		// Byte array holding max bitplanes (8).
	char	value;			// Composed byte(pixel) value.

	source = (char *) src.Get_Buffer();
	destination = (char *) dest.Get_Buffer();

	memset(bytes, '\0', 8);	// Makes sure upper bits will be clear.

	// Each row is grouped and processed together.

	for (index = 0; index < 200 /*bmhd.H*/; index++) {

		// Process each line in groups of 8 bytes.

		for (j = 0; j < 40 /*(bmhd.W>>3)*/; j++) {

			// Get the bitplane bytes.

			for (bplane = 0; bplane < planes /*bmhd.BPlanes*/; bplane++) {
				bytes[bplane] = *(source + (bplane * 40 /*(bmhd.W>>3)*/));
			}
			source++;

			// Roll the bits out to create 8 pixels (by bytes).
			for (i = 0; i < 8; i++) {

				// 8 bits per byte.
				value = 0;
				for (bplane = planes - 1/*bmhd.BPlanes-1*/; bplane >= 0; bplane--) {
					value <<= 1;			// Make room for next bit.
					if (bytes[bplane] & 0x80) value |= 1;	// Set the bit.
					bytes[bplane] <<= 1;
				}
				*destination++ = value;	// Output the pixel byte.
			}
		}

		// Advance to next scan line.
		source += 40 /* (bmhd.W >> 3)*/ * (planes /* bmhd.BPlanes */ - 1);
	}
}


/***************************************************************************
 * ILBM_TO_AMIGA -- Convert ILBM to bitplane Amiga format.                 *
 *                                                                         *
 *    This converts an InterLeaved BitMap picture into Amiga bitplane      *
 *    format (8K per bitplane).  The data of an ILBM picture is controlled *
 *    by the number of bitplanes it contains.  The bitplane count is       *
 *    passed into this program.                                            *
 *                                                                         *
 * INPUT:   src   - Buffer number for source ILBM picture data.            *
 *                                                                         *
 *          dest  - Buffer number for destination Amiga picture data.      *
 *                                                                         *
 *          planes- The number of bitplanes in the source ILBM data.       *
 *                                                                         *
 * OUTPUT:     none                                                        *
 *                                                                         *
 * WARNINGS:   The amount of data placed into the destination buffer is    *
 *             controlled by the number of bitplanes specified.  It is     *
 *             8000 per bitplane.                                          *
 *                                                                         *
 * HISTORY:                                                                *
 *   05/20/1991 JLB : Created.                                             *
 *   04/20/1994 SKB : Update to 32 bit library and make private.           *
 *   04/20/1994 SKB : #if out for main library.  Only used in utils maybe. *
 *=========================================================================*/
#if MAKE_AMIGA_ART
PRIVATE void __cdecl ILBM_To_Amiga(BufferClass& src, BufferClass& dest, int planes)
{
	int	row;			// Working row counter.
	int	bp;			// Working bitplane counter.
	char	*srcptr,		// Source buffer pointer.
			*dstptr;		// Destination buffer pointer.

	srcptr = (char *) src.Get_Buffer();		// Source buffer pointer.
	dstptr = (char *) dest.Get_Buffer();	// Destination buffer pointer.

	for (row = 0; row < 200; row++) {
		for (bp = 0; bp < planes; bp++) {
			Mem_Copy(srcptr,dstptr+(8000*bp),40);
			srcptr += 40;
		}
		dstptr += 40;
	}
}
#endif


/***************************************************************************
 * PBM_TO_AMIGA -- Converts a PBM picture into Amiga format.               *
 *                                                                         *
 *    This converts a PBM (Packed Bit Map) MCGA picture into Amiga         *
 *    bitplane format.  A PBM picture presumes 8 bitplanes, but this       *
 *    can be controlled by the 'plane' parameter passed in.                *
 *                                                                         *
 * INPUT:   src   - Buffer number for the source PBM data.                 *
 *                                                                         *
 *          dest  - Buffer number to place the Amiga format picture.       *
 *                                                                         *
 *          planes- The number of bitplanes to extract from the PBM source *
 *                                                                         *
 * OUTPUT:     none                                                        *
 *                                                                         *
 * WARNINGS:   The amount of data placed into the destination buffer is    *
 *             controlled by the number of bitplanes specified.  It is     *
 *             8000 per bitplane.                                          *
 *                                                                         *
 * HISTORY:                                                                *
 *   05/20/1991 JLB : Created.                                             *
 *   04/20/1994 SKB : Update to 32 bit library and make private.           *
 *   04/20/1994 SKB : #if out for main library.  Only used in utils maybe. *
 *=========================================================================*/
#if MAKE_AMIGA_ART
PRIVATE void __cdecl PBM_To_Amiga(BufferClass& src, BufferClass& dest, int planes)
{
	int	row,							// Working row counter.
			col,							// Working column (by byte) counter.
			bit;							// Working bitplane counter.
	unsigned char	*destptr,		// Destination byte pointer.
						*srcptr;			// Source byte pointer.
	unsigned char	value;			// Working input MCGA pixel number.


	destptr = (unsigned char *) dest.Get_Buffer();
	srcptr = (unsigned char *) src.Get_Buffer();

	memset(destptr, 0, 32000);
	memset(destptr+32000, 0, 32000);

	for (row = 0; row < 200; row++) {

		for (col = 0; col < 320; col++) {
			value = *srcptr++;

			for (bit = 0; bit < planes; bit++) {
				if (value & (0x01 << bit)) {
					destptr[(short)((8000L * (long)bit) + (col>>3))] |= 0x80 >> (col & 0x07);
				}
			}
		}

		destptr += 40;
	}
}
#endif

/***************************************************************************
 * LOAD_PICTURE -- Loads a picture file (CPS or LBM format).               *
 *                                                                         *
 *    This loads a picture file into a page buffer.  The loaded file will  *
 *    be in MCGA or Amiga mode as requested.  Supported source formats     *
 *    are CPS or all forms of IFF dpaint files.                            *
 *                                                                         *
 * INPUT:   filename    - Source filename.  The only files that are        *
 *                        processed as IFF are those files that end with   *
 *                        ".LBM".                                          *
 *                                                                         *
 *          loadbuf     - Buffer type number for the temporary loading     *
 *                        buffer.  It will be trashed.                     *
 *                                                                         *
 *          destbuf     - Buffer type number for the picture to be placed. *
 *                                                                         *
 *          palette     - Palette buffer pointer.  If this value is NULL   *
 *                        then no palette is loaded.                       *
 *                                                                         *
 *          format      - Desired destination format.                      *
 *                      BM_AMIGA - Destination buffer will contain the     *
 *                                 picture in bitplane format (Amiga).     *
 *                                 The buffer will contain data equal to   *
 *                                 8K times the number of bit planes.      *
 *                                                                         *
 *                      BM_MCGA  - Destination buffer will contain the     *
 *                                 picture in MCGA format (byte per pixel).*
 *                                 The buffer will be 64K in size.         *
 *                                                                         *
 * OUTPUT:  int number of bitplanes read into the dest buffer					*
 *                                                                         *
 * WARNINGS:   none                                                        *
 *                                                                         *
 * HISTORY:                                                                *
 *   05/16/1991 JLB : Created.                                             *
 *   05/20/1991 JLB : Handles Amiga and IBM destination formats.           *
 *=========================================================================*/
int __cdecl Load_Picture(char const *filename, BufferClass& scratchbuf, BufferClass& destbuf, unsigned char *palette, PicturePlaneType format)
{
	int	fh;						// Input file handle.
	long	ifftype;					// Iff form type.
	int	counter;					// Count of the bytes decompressed.
	int	value;					// Working compression code value.
	int	len;						// int sized length value.
	int	index;					// Working index values.
	BitMapHeader_Type	bmhd;		// BMHD chunk data.
	IFFForm_Type	   formtype; // ILBM, PBM.
	char	*src;						 // Working source body pointer.
	char	*dest;					 // Working destination body pointer.


	//len = strlen(filename);
	//strupr(filename);

	fh = Open_File(filename,READ);
	if (fh == WW_ERROR) return(FALSE);
	Read_File(fh,&ifftype,4L);
	Close_File(fh);

	if (ifftype != ID_FORM) {
		return((int)Load_Uncompress(filename, scratchbuf, destbuf,  palette ) / 8000 ) ;
	} else {

		fh = Open_Iff_File(filename);	// Opens and checks for IFF form.
		if (fh == WW_ERROR) return(FALSE);

		Read_File(fh, &ifftype, 4L);
		if (ifftype == ID_ILBM) {
			formtype = FORM_ILBM;				// Inter-Leaved Bit Map.
		} else {
			if (ifftype == ID_PBM) {
				formtype = FORM_PBM;			// Packed Bit Map.
			} else {
				return FALSE;				// Not a recognizable picture file.
			}
		}

		// Load the BMHD chunk.
		if (Read_Iff_Chunk(fh,ID_BMHD,(char*)&bmhd,sizeof(BitMapHeader_Type))) {

			#if(IBM)
				// Perform necessary IBM conversions to the data.
				bmhd.W = Reverse_Short(bmhd.W);
				bmhd.H = Reverse_Short(bmhd.H);
				bmhd.X = Reverse_Short(bmhd.X);
				bmhd.Y = Reverse_Short(bmhd.Y);

				// this is a mistake Xaspect and YAspect are char type
				// bmhd.XAspect = Reverse_Short(bmhd.XAspect);
				// bmhd.YAspect = Reverse_Short(bmhd.YAspect);
				  value = bmhd.XAspect	;
				  bmhd.XAspect = bmhd.YAspect ;
				  bmhd.YAspect = ( unsigned char ) value ;

				bmhd.PageWidth = Reverse_Short(bmhd.PageWidth);
				bmhd.PageHeight = Reverse_Short(bmhd.PageHeight);
			#endif

			if (bmhd.Masking > 2) return FALSE;			// Don't allow brushes.
			if (bmhd.Compression > 1) return FALSE;	// Unknown compression.

		} else {
			return FALSE;				// Unable to read the required BMHD chunk.
		}

		// Load the palette if asked.
		if (palette)
		{
			int	pbytes ;			       	// Number of CMAP bytes required.
			unsigned char	color;			// Palette color value.
			unsigned char *paletteptr;		// Allocated buffer for palette conversions.
			unsigned char *source;		  	// Scratch source CMAP data pointer.
			unsigned char *dest2;		  	// Scratch destination palette pointer.

			//	Number of CMAP bytes that are needed.
			pbytes = (1 << bmhd.BPlanes) * 3;

			// Allocate the temporary palette buffer.
			paletteptr = (unsigned char *)Alloc(pbytes, MEM_CLEAR);
			source = paletteptr;
			dest2 = palette;

			//	Read in only the bytes that are needed.
			pbytes = (int)Read_Iff_Chunk(fh, ID_CMAP, (char *) paletteptr, pbytes);

			if (pbytes) {

				/*
				** CMAP to machine specific palette conversion code.  Conversion
				**	goes from CMAP three bytes per color register to the machine
				**	specific form.
				*/
				switch(format) {
					default:
					case BM_MCGA:
						// Convert CMAP to IBM MCGA palette form.
						for (index = 0; index < pbytes; index++) {
							*dest2++ = *source++ >> 2;
						}
						break;
#if MAKE_AMIGA_ART

					case BM_AMIGA:
						// Convert CMAP to Amiga nibble packed palette form.
						for (index = 0; index < pbytes; index += 3) {
							*dest2++   = *(source++) >> 4;
							color 	 = (*(source++) & 0xf0);
							color 	+= *(source++) >> 4;
							*dest2++	 = color;
						}

						break;
#endif
				}
			}

			Free(paletteptr);
		}


		//	Load in BODY chunk.
		dest = (char *) scratchbuf.Get_Buffer();
		src  = (char *) destbuf.Get_Buffer();

		if (Read_Iff_Chunk(fh, ID_BODY, src, destbuf.Get_Size()))
		{
			for (index = 0; index < (short)bmhd.H; index++)
			{
			   /* Height of source */
				//	Transfer (possibly uncompress) one row of data.
				// PBM or ILBM reader. Bytes per row (all bitplanes).

				counter = bmhd.BPlanes * (bmhd.W >> 3);

				//	If there is a mask then there is one more bitplane.
				if (bmhd.Masking == 1)
											counter += bmhd.W >> 3 ;

				if (bmhd.Compression == 1)
				{
				   // The data is compressed.
					//	Decompress one scanline (all bitplanes) at a time.
					while (counter)
					{
						value = ( signed char ) *src++; 			// Decompression code.
						if (value == -128) continue;	// NOOP code.

						if (value >= 0)
						{
							// Copy N+1 bytes.
							len = ((short) value) + 1;

							//	Ignore the masking bitplane.
							if ( bmhd.Masking != 1 ||
							     (bmhd.Masking==1 && counter > ((short)bmhd.W >> 3) ) )
							{
								memcpy(dest, src, len);
								dest += len;
							}
							counter -= len;
							src += len;

						}
						else
						{
							// Replicate -N+1 bytes.
							len = (-((short) value)) + 1;
							value = *src++;

							//	Ignore the masking bitplane.
							if (bmhd.Masking != 1 || (bmhd.Masking==1 && counter > ((short)bmhd.W >> 3)))
							{
								memset(dest,value,len);
								dest += len;
							}
							counter -= len;
						}
					}
				}

				else
				{
				   // Plain data is just copied.
					memcpy(dest,src,counter);
					dest += counter;
					src += counter;
				}
			}

			/*
			**	Perform necessary conversions to the data in order to reach
			**	the desired format.
			*/
			switch (format) {
				default:
				case BM_MCGA:			// Byte per pixel desired.
					if (formtype == FORM_ILBM) {
						ILBM_To_MCGA(scratchbuf, destbuf, bmhd.BPlanes);
					} else {
						Mem_Copy(scratchbuf.Get_Buffer(), destbuf.Get_Buffer(), 64000L);
					}
					break;

#if MAKE_AMIGA_ART
				case BM_AMIGA:			// Bitplane format desired.
					if (formtype == FORM_ILBM) {
						ILBM_To_Amiga(scratchbuf, destbuf, bmhd.BPlanes);
					} else {
						PBM_To_Amiga(scratchbuf, destbuf, bmhd.BPlanes);
					}
					break;
#endif
			}
		}

		Close_Iff_File(fh);
	}

	return((short)bmhd.BPlanes);			// Loaded the picture successfully.
}