1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
|
/* gameplaySP
*
* Copyright (C) 2006 Exophase <exophase@gmail.com>
* Copyright (C) 2006 SiberianSTAR
*
* 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 2 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, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
#include "common.h"
#include <zlib.h>
#define ZIP_BUFFER_SIZE (128 * 1024)
struct SZIPFileDataDescriptor
{
s32 CRC32;
s32 CompressedSize;
s32 UncompressedSize;
} __attribute__((packed));
struct SZIPFileHeader
{
char Sig[4]; // EDIT: Used to be s32 Sig;
s16 VersionToExtract;
s16 GeneralBitFlag;
s16 CompressionMethod;
s16 LastModFileTime;
s16 LastModFileDate;
struct SZIPFileDataDescriptor DataDescriptor;
s16 FilenameLength;
s16 ExtraFieldLength;
} __attribute__((packed));
u32 load_file_zip(const char *filename)
{
struct SZIPFileHeader data;
char tmp[1024];
s32 retval = -1;
u8 *buffer = NULL;
u8 *cbuffer;
char *ext;
int ret;
FILE *fd;
fd = fopen(filename, "rb");
if(!fd)
return -1;
while (1)
{
ret = fread(&data, 1, sizeof(data), fd);
if (ret != sizeof(data))
break;
// It checks for the following: 0x50 0x4B 0x03 0x04 (PK..)
if( data.Sig[0] != 0x50 || data.Sig[1] != 0x4B ||
data.Sig[2] != 0x03 || data.Sig[3] != 0x04 )
{
break;
}
ret = fread(tmp, 1, data.FilenameLength, fd);
if (ret != data.FilenameLength)
break;
tmp[data.FilenameLength] = 0; // end string
if(data.ExtraFieldLength)
fseek(fd, data.ExtraFieldLength, SEEK_CUR);
if(data.GeneralBitFlag & 0x0008)
{
fread(&data.DataDescriptor,
1, sizeof(struct SZIPFileDataDescriptor), fd);
}
ext = strrchr(tmp, '.') + 1;
// file is too big
if(data.DataDescriptor.UncompressedSize > gamepak_ram_buffer_size)
goto skip;
if(!strcasecmp(ext, "bin") || !strcasecmp(ext, "gba"))
{
buffer = gamepak_rom;
// ok, found
switch(data.CompressionMethod)
{
case 0:
retval = data.DataDescriptor.UncompressedSize;
fread(buffer, 1, retval, fd);
goto outcode;
case 8:
{
z_stream stream;
s32 err;
cbuffer = malloc(ZIP_BUFFER_SIZE);
stream.next_in = (Bytef*)cbuffer;
stream.avail_in = (u32)ZIP_BUFFER_SIZE;
stream.next_out = (Bytef*)buffer;
// EDIT: Now uses proper conversion of data types for retval.
retval = (u32)data.DataDescriptor.UncompressedSize;
stream.avail_out = data.DataDescriptor.UncompressedSize;
stream.zalloc = (alloc_func)0;
stream.zfree = (free_func)0;
err = inflateInit2(&stream, -MAX_WBITS);
fread(cbuffer, 1, ZIP_BUFFER_SIZE, fd);
if(err == Z_OK)
{
while(err != Z_STREAM_END)
{
err = inflate(&stream, Z_SYNC_FLUSH);
if(err == Z_BUF_ERROR)
{
stream.avail_in = ZIP_BUFFER_SIZE;
stream.next_in = (Bytef*)cbuffer;
fread(cbuffer, 1, ZIP_BUFFER_SIZE, fd);
}
}
err = Z_OK;
inflateEnd(&stream);
}
free(cbuffer);
goto outcode;
}
}
}
skip:
fseek(fd, data.DataDescriptor.CompressedSize, SEEK_CUR);
}
outcode:
fclose(fd);
return retval;
}
|
