Genesis-Plus-GX/gx/fileio/fileio.c

304 lines
8.1 KiB
C

/*
* fileio.c
*
* Load a normal file, or ZIP/GZ archive into ROM buffer.
* Returns loaded ROM size (zero if an error occured).
*
* Copyright Eke-Eke (2007-2014), based on original work from Softdev (2006)
*
* Redistribution and use of this code or any derivative works are permitted
* provided that the following conditions are met:
*
* - Redistributions may not be sold, nor may they be used in a commercial
* product or activity.
*
* - Redistributions that are modified from the original source must include the
* complete source code, including the source code for all components used by a
* binary built from the modified sources. However, as a special exception, the
* source code distributed need not include anything that is normally distributed
* (in either source or binary form) with the major components (compiler, kernel,
* and so on) of the operating system on which the executable runs, unless that
* component itself accompanies the executable.
*
* - Redistributions must reproduce the above copyright notice, this list of
* conditions and the following disclaimer in the documentation and/or other
* materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
****************************************************************************************/
#include "shared.h"
#include "file_load.h"
#include "gui.h"
/*
* Zip file header definition
*/
typedef struct
{
unsigned int zipid __attribute__ ((__packed__)); // 0x04034b50
unsigned short zipversion __attribute__ ((__packed__));
unsigned short zipflags __attribute__ ((__packed__));
unsigned short compressionMethod __attribute__ ((__packed__));
unsigned short lastmodtime __attribute__ ((__packed__));
unsigned short lastmoddate __attribute__ ((__packed__));
unsigned int crc32 __attribute__ ((__packed__));
unsigned int compressedSize __attribute__ ((__packed__));
unsigned int uncompressedSize __attribute__ ((__packed__));
unsigned short filenameLength __attribute__ ((__packed__));
unsigned short extraDataLength __attribute__ ((__packed__));
} PKZIPHEADER;
/*
* Zip files are stored little endian
* Support functions for short and int types
*/
static inline u32 FLIP32 (u32 b)
{
unsigned int c;
c = (b & 0xff000000) >> 24;
c |= (b & 0xff0000) >> 8;
c |= (b & 0xff00) << 8;
c |= (b & 0xff) << 24;
return c;
}
static inline u16 FLIP16 (u16 b)
{
u16 c;
c = (b & 0xff00) >> 8;
c |= (b & 0xff) << 8;
return c;
}
int load_archive(char *filename, unsigned char *buffer, int maxsize, char *extension)
{
int size = 0;
char in[CHUNKSIZE];
char msg[64];
char type[16];
/* Open file */
FILE *fd = fopen(filename, "rb");
/* Autodetect needed System ROM files */
if (filename == CD_BIOS_US)
{
sprintf(type,"CD BIOS (USA)");
}
else if (filename == CD_BIOS_EU)
{
sprintf(type,"CD BIOS (PAL)");
}
else if (filename == CD_BIOS_JP)
{
sprintf(type,"CD BIOS (JAP)");
}
else if (filename == AR_ROM)
{
sprintf(type,"Action Replay");
}
else if (filename == GG_ROM)
{
sprintf(type,"Game Genie");
}
else if (filename == SK_ROM)
{
sprintf(type,"S&K (2MB ROM)");
}
else if (filename == SK_UPMEM)
{
sprintf(type,"S2&K (256K ROM)");
}
else if ((filename == MS_BIOS_US) || (filename == MS_BIOS_EU) || (filename == MS_BIOS_JP) || (filename == GG_BIOS) || (filename == MD_BIOS))
{
/* Mega Drive / Genesis, Master System & Game Gear BIOS are optional so we disable error messages */
SILENT = 1;
}
else
{
sprintf(type,"file");
}
if (!fd)
{
sprintf(msg,"Unable to open %s", type);
GUI_WaitPrompt("Error", msg);
SILENT = 0;
return 0;
}
/* Read first chunk */
fread(in, CHUNKSIZE, 1, fd);
/* Detect Zip file */
if (memcmp(in, "PK", 2) == 0)
{
/* Inflate buffer */
char out[CHUNKSIZE];
/* PKZip header pointer */
PKZIPHEADER *pkzip = (PKZIPHEADER *) in;
/* Retrieve uncompressed ROM size */
size = FLIP32(pkzip->uncompressedSize);
/* Check ROM size */
if (size > MAXROMSIZE)
{
fclose(fd);
GUI_WaitPrompt("Error","File is too large");
SILENT = 0;
return 0;
}
else if (size > maxsize)
{
size = maxsize;
}
sprintf (msg, "Unzipping %d bytes ...", size);
GUI_MsgBoxUpdate("Information",msg);
/* Initialize zip stream */
z_stream zs;
memset (&zs, 0, sizeof (z_stream));
zs.zalloc = Z_NULL;
zs.zfree = Z_NULL;
zs.opaque = Z_NULL;
zs.avail_in = 0;
zs.next_in = Z_NULL;
int res = inflateInit2(&zs, -MAX_WBITS);
if (res != Z_OK)
{
fclose(fd);
sprintf(msg,"Unable to unzip %s", type);
GUI_WaitPrompt("Error",msg);
SILENT = 0;
return 0;
}
/* Compressed filename offset */
int offset = sizeof (PKZIPHEADER) + FLIP16(pkzip->filenameLength);
if (extension)
{
memcpy(extension, &in[offset - 3], 3);
extension[3] = 0;
}
/* Initial Zip buffer offset */
offset += FLIP16(pkzip->extraDataLength);
zs.next_in = (Bytef *)&in[offset];
/* Initial Zip remaining chunk size */
zs.avail_in = CHUNKSIZE - offset;
/* Initialize output size */
size = 0;
/* Start unzipping file */
do
{
/* Inflate data until output buffer is empty */
do
{
zs.avail_out = CHUNKSIZE;
zs.next_out = (Bytef *) out;
res = inflate(&zs, Z_NO_FLUSH);
if (res == Z_MEM_ERROR)
{
inflateEnd(&zs);
fclose(fd);
sprintf(msg,"Unable to unzip %s", type);
GUI_WaitPrompt("Error",msg);
SILENT = 0;
return 0;
}
offset = CHUNKSIZE - zs.avail_out;
if ((size + offset) > maxsize)
{
offset = maxsize - size;
}
if (offset)
{
memcpy(buffer, out, offset);
buffer += offset;
size += offset;
}
}
while ((zs.avail_out == 0) && (size < maxsize));
/* Read next chunk of zipped data */
fread(in, CHUNKSIZE, 1, fd);
zs.next_in = (Bytef *)&in[0];
zs.avail_in = CHUNKSIZE;
}
while ((res != Z_STREAM_END) && (size < maxsize));
inflateEnd (&zs);
}
else
{
/* Get file size */
fseek(fd, 0, SEEK_END);
size = ftell(fd);
fseek(fd, 0, SEEK_SET);
/* Check ROM size */
if (size > MAXROMSIZE)
{
fclose(fd);
GUI_WaitPrompt("Error","File is too large");
SILENT = 0;
return 0;
}
else if (size > maxsize)
{
size = maxsize;
}
sprintf((char *)msg,"Loading %d bytes ...", size);
GUI_MsgBoxUpdate("Information", (char *)msg);
/* filename extension */
if (extension)
{
memcpy(extension, &filename[strlen(filename) - 3], 3);
extension[3] = 0;
}
/* Read into buffer */
int left = size;
while (left > CHUNKSIZE)
{
fread(buffer, CHUNKSIZE, 1, fd);
buffer += CHUNKSIZE;
left -= CHUNKSIZE;
}
/* Read remaining bytes */
fread(buffer, left, 1, fd);
}
/* Close file */
fclose(fd);
/* Return loaded ROM size */
SILENT = 0;
return size;
}