GeneralsZeroHour/Generals/Code/Tools/Babylon/iff.cpp

/*
**	Command & Conquer Generals(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/>.
*/


#include "stdAfx.h"
#include "sys/stat.h"
#include "iff.h"
#include <fcntl.h>      
#include <io.h>
#include <stdlib.h>
#include <stdio.h>

#define IFF_RAWREAD(iff,data,size,label)		{if ( IFF_rawread ( (iff), (data), (size)) != (size)) goto label;}


int		IFF_rawread ( IFF_FILE *iff, void *buffer, int bytes )
{
	if ( ! (iff->flags & mIFF_FILE_LOADED ) )
	{
		return	_read ( iff->fp, buffer, bytes );
	}

	if ( iff->file_size < (iff->file_pos + bytes) )
	{
		bytes = iff->file_size - iff->file_pos;
	}
	memcpy ( buffer, &iff->mem_file[iff->file_pos], bytes );
	iff->file_pos += bytes;
	return bytes;
}

/******************************************************************/
/*                                                                */
/*                                                                */
/******************************************************************/

int		IFF_seek ( IFF_FILE *iff, int pos, int mode )
{

	if ( ! (iff->flags & mIFF_FILE_LOADED ))
	{
		return	lseek ( iff->fp, pos, mode );
	}

	switch ( mode )
	{
		case SEEK_CUR:
			iff->file_pos += pos;
			break;
		case SEEK_END:
			iff->file_pos = iff->file_size - pos;
			break;
		case SEEK_SET:
			iff->file_pos = pos;
			break;
	}

	if ( iff->file_pos < 0 )
	{
		iff->file_pos = 0;
	}
	else
	{
		if ( iff->file_pos > iff->file_size )
		{
			iff->file_pos = iff->file_size;
		}
	}

	return iff->file_pos;
}

/******************************************************************/
/*                                                                */
/*                                                                */
/******************************************************************/

IFF_FILE	*IFF_Open ( const char *name )
{
	IFF_FILE *iff = NULL;


	if ( ! (iff = (IFF_FILE *) malloc ( sizeof (IFF_FILE))))
	{
		goto error;
	}

	iff->fp = -1;
	memset ( iff, 0, sizeof ( IFF_FILE ));

	if ((iff->fp = open ( name, _O_BINARY | _O_RDONLY )) == -1 )
	{
		goto error;
	}


	return iff;

error:

	if (iff)
	{
		IFF_Close ( iff );
	}

	return NULL;
}

/******************************************************************/
/*                                                                */
/*                                                                */
/******************************************************************/

IFF_FILE	*IFF_Load ( const char *name )
{
	IFF_FILE *iff = NULL;

	if ( ! (iff = (IFF_FILE *) malloc ( sizeof (IFF_FILE))))
	{
		goto error;
	}

	memset ( iff, 0, sizeof ( IFF_FILE ));
	iff->fp = -1;

	if ((iff->fp = open ( name, _O_BINARY | _O_RDONLY )) == -1 )
	{
		goto error;
	}

	iff->file_size = lseek ( iff->fp, 0, SEEK_END );
	lseek ( iff->fp, 0, SEEK_SET );

	if ( !(iff->mem_file = ( char *) malloc ( iff->file_size) ) )
	{
		goto error;
	}

	DO_READ ( iff->fp, iff->mem_file, iff->file_size, error );

	iff->flags |= mIFF_FILE_LOADED;

	return iff;

error:

	if (iff)
	{
		IFF_Close ( iff );
	}

	return NULL;
}

/******************************************************************/
/*                                                                */
/*                                                                */
/******************************************************************/

void	IFF_Reset ( IFF_FILE *iff )
{
	IFF_seek ( iff, 0, SEEK_SET );
	iff->pad_form = 0;
	iff->pad_chunk = 0;
	iff->FormSize = 0;
	iff->ChunkSize = 0;
	iff->next_byte = 0;
	iff->chunk_size_pos = 0;
	iff->form_size_pos = 0;

}

/******************************************************************/
/*                                                                */
/*                                                                */
/******************************************************************/

void	IFF_goto_form_end ( IFF_FILE *iff )
{

	iff->FormSize += iff->pad_form;
	iff->pad_form = 0;
	if (iff->FormSize)
	{
		IFF_seek ( iff, iff->FormSize, SEEK_CUR );
		iff->next_byte += iff->FormSize;
		iff->FormSize = 0;
		iff->ChunkSize = 0;
	}

}

/******************************************************************/
/*                                                                */
/*                                                                */
/******************************************************************/

void	IFF_goto_chunk_end ( IFF_FILE *iff )
{

	iff->ChunkSize += iff->pad_chunk;
	iff->pad_chunk = 0;
	if (iff->ChunkSize)
	{
		IFF_seek ( iff, iff->ChunkSize, SEEK_CUR );
		iff->next_byte += iff->ChunkSize;
		iff->FormSize -= iff->ChunkSize;
		iff->ChunkSize = 0;
	}
}



/******************************************************************/
/*                                                                */
/*                                                                */
/******************************************************************/

int		IFF_NextForm ( IFF_FILE *iff )
{
	IFF_CHUNK chunk;
	int	form;

   	IFF_goto_form_end ( iff );

   	IFF_RAWREAD (iff, &chunk, sizeof( IFF_CHUNK ), error );

   	chunk.Size = 	BgEn32 (chunk.Size);
   	chunk.ID =  	BgEn32 (chunk.ID);

   	iff->pad_form = (int) (chunk.Size & 0x0001);

   	if (chunk.ID != vIFF_ID_FORM )
	{
   		goto error;
	}

   	IFF_RAWREAD (iff, &form, sizeof( int ), error);

   	iff->FormID = 	(int) BgEn32 (form);

   	iff->flags |= mIFF_FILE_FORMOPEN;
   	iff->next_byte += sizeof( int ) + sizeof ( IFF_CHUNK );
   	iff->FormSize = (int) chunk.Size - sizeof ( int );
   	iff->ChunkSize = 0;
   	iff->pad_chunk = 0;

   	return 	TRUE;

error:

   	return	FALSE;
}

/******************************************************************/
/*                                                                */
/*                                                                */
/******************************************************************/

int		IFF_NextChunk ( IFF_FILE *iff )
{
	IFF_CHUNK chunk;

	IFF_goto_chunk_end ( iff );

	if (iff->FormSize==0)
	{
		goto error;
	}

	IFF_RAWREAD ( iff, &chunk, sizeof( IFF_CHUNK ), error );

	chunk.Size = 	BgEn32 (chunk.Size);
	chunk.ID =  	BgEn32 (chunk.ID);

	iff->pad_chunk = (int) (chunk.Size & 0x0001);

	iff->flags |= mIFF_FILE_CHUNKOPEN;
	iff->ChunkID = (int) chunk.ID;
	iff->ChunkSize = (int) chunk.Size;
	iff->next_byte +=  sizeof ( IFF_CHUNK );
	iff->FormSize -= sizeof ( IFF_CHUNK );

	return 	TRUE;

error:

	return	FALSE;
}

/******************************************************************/
/*                                                                */
/*                                                                */
/******************************************************************/

void	IFF_Close ( IFF_FILE *iff )
{
	if (iff->fp != -1)
	{
		_close (iff->fp);
	}

	if ( iff->mem_file )
	{
		free ( iff->mem_file );
	}

	free ( iff );
}

/******************************************************************/
/*                                                                */
/*                                                                */
/******************************************************************/

int		IFF_Read ( IFF_FILE *iff, void *buff, int size )
{
	int	read =0;

	if ( size>iff->ChunkSize )
	{
		size = iff->ChunkSize;
	}

	read = IFF_rawread ( iff, buff, size);

	if (read==-1)
	{
		read = 0;
	}

	iff->ChunkSize -= read;
	iff->FormSize -= read;
	iff->next_byte += read;


	return read;
}

/******************************************************************/
/*                                                                */
/*                                                                */
/******************************************************************/

IFF_FILE		*IFF_New ( const char *name )
{
	IFF_FILE *iff = NULL;


	if ( ! (iff = (IFF_FILE *) malloc ( sizeof (IFF_FILE))))
	{
		goto error;
	}

	memset ( iff, 0, sizeof ( IFF_FILE ));
	iff->fp = -1;

	if ((iff->fp = _open ( name, _O_BINARY | _O_RDWR | _O_CREAT | _O_TRUNC, _S_IREAD | _S_IWRITE )) == -1 )
	{
		goto error;
	}

	return iff;

error:

	if (iff)
	{
		IFF_Close ( iff );
	}

	return NULL;
}

/******************************************************************/
/*                                                                */
/*                                                                */
/******************************************************************/

int		IFF_NewForm	( IFF_FILE *iff, int id )
{
	IFF_CHUNK chunk;

	chunk.ID = BgEn32 (vIFF_ID_FORM);
	chunk.Size = BgEn32 (90000);

	iff->FormSize = 0;
	iff->ChunkSize = 0;
	iff->FormID = id;

	DO_WRITE ( iff->fp, &chunk, sizeof (IFF_CHUNK), error);

	chunk.ID = BgEn32 ( (int) iff->FormID);
	DO_WRITE ( iff->fp, &chunk.ID, sizeof (int), error );

	iff->flags |= mIFF_FILE_FORMOPEN;
	iff->form_size_pos = iff->next_byte + sizeof (int);
	iff->next_byte += sizeof ( IFF_CHUNK ) + sizeof (int);

	return 	TRUE;

error:

	return	FALSE;
}

/******************************************************************/
/*                                                                */
/*                                                                */
/******************************************************************/

int			IFF_NewChunk ( IFF_FILE *iff, int id )
{
	IFF_CHUNK chunk;

	chunk.Size = 	BgEn32 (90000);
	chunk.ID =  	BgEn32 ( (int) id);


	DO_WRITE ( iff->fp, &chunk, sizeof ( IFF_CHUNK ), error );

	iff->flags |= mIFF_FILE_CHUNKOPEN;
	iff->chunk_size_pos = iff->next_byte + sizeof (int);
	iff->next_byte += sizeof ( IFF_CHUNK ) ;
	iff->FormSize += sizeof ( IFF_CHUNK ) ;
	iff->ChunkSize = 0;
	iff->ChunkID = id;

	return 	TRUE;

error:

	return	FALSE;

}

/******************************************************************/
/*                                                                */
/*                                                                */
/******************************************************************/

int		IFF_Write ( IFF_FILE *iff, void *buff, int size )
{
	int	val =0;

	val = _write ( iff->fp, buff, size);
								
	if (val==-1)
	{
		val = 0;
	}

	iff->ChunkSize += val;
	iff->FormSize += val;
	iff->next_byte += val;


	return val;
}

/******************************************************************/
/*                                                                */
/*                                                                */
/******************************************************************/

int		IFF_CloseForm ( IFF_FILE *iff )
{
	int	fp;
	int	off;
	int	size;
	int	pad = 0;

	if (iff && ((fp = iff->fp) != -1))
	{

		if (iff->FormSize&0x0001)
		{
			DO_WRITE (fp, &pad, 1, error );
			iff->next_byte++;
		}

		off = iff->next_byte - iff->form_size_pos;

		size = BgEn32 ( (int) (iff->FormSize+sizeof ( int )));

		if (lseek (fp, -off, SEEK_CUR)==iff->form_size_pos)
		{
			DO_WRITE ( fp, &size, sizeof (int), error );
			lseek ( fp, 0, SEEK_END);
			return TRUE;
		}
	}

error:

	return FALSE;
}


/******************************************************************/
/*                                                                */
/*                                                                */
/******************************************************************/

int		IFF_CloseChunk ( IFF_FILE *iff )
{
	int		fp;
	int		off;
	int		size;
	int		pad = 0;

	if (iff && ((fp = iff->fp) != -1 ))
	{

		if (iff->ChunkSize&0x0001)
		{
			DO_WRITE (fp, &pad, 1, error );
			iff->next_byte++;
			iff->FormSize++;
		}

		off = iff->next_byte - iff->chunk_size_pos;

		size = BgEn32 ((int) iff->ChunkSize);

		if (lseek (fp, -off, SEEK_CUR)==iff->chunk_size_pos)
		{
			DO_WRITE ( fp, &size, sizeof (int), error );
			lseek ( fp, 0, SEEK_END);
			return TRUE;
		}
	}

error:

	return TRUE;
}