|
0
|
1 bool init_end=false;
|
|
|
2 /* file.cc : KANON の圧縮ファイル・PDT ファイル（画像ファイル）の展開の
|
|
|
3 * ためのメソッド
|
|
|
4 * class ARCFILE : 書庫ファイル全体を扱うクラス
|
|
|
5 * class ARCINFO : 書庫ファイルの中の１つのファイルを扱うクラス
|
|
|
6 * class PDTCONV : PDT ファイルの展開を行う。
|
|
|
7 *
|
|
|
8 */
|
|
|
9
|
|
|
10 /*
|
|
|
11 *
|
|
|
12 * Copyright (C) 2000- Kazunori Ueno(JAGARL) <jagarl@creator.club.ne.jp>
|
|
|
13 *
|
|
|
14 * This program is free software; you can redistribute it and/or modify
|
|
|
15 * it under the terms of the GNU General Public License as published by
|
|
|
16 * the Free Software Foundation; either version 2 of the License, or
|
|
|
17 * (at your option) any later version.
|
|
|
18 *
|
|
|
19 * This program is distributed in the hope that it will be useful,
|
|
|
20 * but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
21 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
22 * GNU General Public License for more details.
|
|
|
23 *
|
|
|
24 * You should have received a copy of the GNU General Public License
|
|
|
25 * along with this program; if not, write to the Free Software
|
|
|
26 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
|
|
27 *
|
|
|
28 */
|
|
|
29
|
|
|
30 #ifdef HAVE_CONFIG_H
|
|
|
31 # include "config.h"
|
|
|
32 #endif
|
|
|
33
|
|
|
34 #ifdef HAVE_MMAP
|
|
|
35 # ifdef MACOSX
|
|
|
36 # undef HAVE_MMAP
|
|
|
37 # endif /* MACOSX */
|
|
|
38 #endif /* HAVE_MMAP */
|
|
|
39
|
|
|
40 #include <ctype.h>
|
|
|
41 #include <fcntl.h>
|
|
|
42 #include <unistd.h>
|
|
|
43 #include <stdlib.h>
|
|
|
44 #include <stdio.h>
|
|
|
45 #include <sys/types.h>
|
|
|
46 #include <sys/stat.h>
|
|
|
47 #include <vector>
|
|
|
48 #include <algorithm>
|
|
|
49 #if HAVE_MMAP
|
|
|
50 #include<sys/mman.h>
|
|
|
51 #endif /* HAVE_MMAP */
|
|
|
52 #if HAVE_DIRENT_H
|
|
|
53 # include <dirent.h>
|
|
|
54 # define NAMLEN(dirent) strlen((dirent)->d_name)
|
|
|
55 #else
|
|
|
56 # define dirent direct
|
|
|
57 # define NAMLEN(dirent) (dirent)->d_namlen
|
|
|
58 # if HAVE_SYS_NDIR_H
|
|
|
59 # include <sys/ndir.h>
|
|
|
60 # endif
|
|
|
61 # if HAVE_SYS_DIR_H
|
|
|
62 # include <sys/dir.h>
|
|
|
63 # endif
|
|
|
64 # if HAVE_NDIR_H
|
|
|
65 # include <ndir.h>
|
|
|
66 # endif
|
|
|
67 #endif
|
|
|
68
|
|
|
69 #if HAVE_LIBZ
|
|
|
70 #include<zlib.h>
|
|
|
71 #endif
|
|
|
72 #if HAVE_LIBPNG
|
|
|
73 #include<png.h>
|
|
|
74 #endif
|
|
|
75 #if HAVE_LIBJPEG
|
|
|
76 extern "C" {
|
|
|
77 #include<jpeglib.h>
|
|
|
78 }
|
|
|
79 #endif
|
|
|
80
|
|
|
81 #include "file.h"
|
|
|
82 #include "file_impl.h"
|
|
|
83
|
|
|
84 using namespace std;
|
|
|
85
|
|
|
86 FILESEARCH file_searcher;
|
|
|
87 // #define delete fprintf(stderr,"file.cc: %d.",__LINE__), delete
|
|
|
88
|
|
|
89 /* FILESEARCH class の default の振る舞い */
|
|
|
90 FILESEARCH::ARCTYPE FILESEARCH::default_is_archived[TYPEMAX] = {
|
|
|
91 ATYPE_DIR, ATYPE_DIR, ATYPE_DIR, ATYPE_DIR,
|
|
|
92 ATYPE_ARC, ATYPE_ARC, ATYPE_ARC, ATYPE_ARC,
|
|
|
93 ATYPE_DIR, ATYPE_DIR, ATYPE_DIR, ATYPE_DIR,
|
|
|
94 ATYPE_DIR, ATYPE_DIR
|
|
|
95 };
|
|
|
96 char* FILESEARCH::default_dirnames[TYPEMAX] = {
|
|
|
97 0, 0, "", "pdt",
|
|
|
98 "seen.txt", "allanm.anl", "allard.ard", "allcur.cur",
|
|
|
99 0, 0, "koe", "bgm", "mov", "gan"};
|
|
|
100
|
|
|
101 /*********************************************
|
|
|
102 ** ARCFILE / DIRFILE:
|
|
|
103 ** 書庫ファイル、あるいはディレクトリの
|
|
|
104 ** 全体を管理するクラス
|
|
|
105 **
|
|
|
106 ** 書庫ファイルからファイルの抜き出しはFind()
|
|
|
107 ** Find したものをReadすると内容が得られる。
|
|
|
108 */
|
|
|
109
|
|
|
110 ARCFILE::ARCFILE(char* aname) {
|
|
|
111 struct stat sb;
|
|
|
112 /* 変数初期化 */
|
|
|
113 arcname = 0;
|
|
|
114 list_point = 0;
|
|
|
115 filenames_orig = 0;
|
|
|
116 next = 0;
|
|
|
117 if (aname[0] == '\0') {arcname=new char[1]; arcname[0]='\0';return;} // NULFILE
|
|
|
118 /* ディレクトリか否かのチェック */
|
|
|
119 if (stat(aname,&sb) == -1) { /* error */
|
|
|
120 perror("stat");
|
|
|
121 }
|
|
|
122 if ( (sb.st_mode&S_IFMT) == S_IFDIR) {
|
|
|
123 int l = strlen(aname);
|
|
|
124 arcname = new char[l+2]; strcpy(arcname, aname);
|
|
|
125 if (arcname[l-1] != DIR_SPLIT) {
|
|
|
126 arcname[l] = DIR_SPLIT;
|
|
|
127 arcname[l+1] = 0;
|
|
|
128 }
|
|
|
129 } else if ( (sb.st_mode&S_IFMT) == S_IFREG) {
|
|
|
130 arcname = new char[strlen(aname)+1];
|
|
|
131 strcpy(arcname,aname);
|
|
|
132 if (arcname[strlen(arcname)-1] == DIR_SPLIT)
|
|
|
133 arcname[strlen(arcname)-1] = '\0';
|
|
|
134 }
|
|
|
135 return;
|
|
|
136 }
|
|
|
137
|
|
|
138 void ARCFILE::Init(void) {
|
|
|
139 int i;
|
|
|
140 if (! arc_atom.empty()) return;
|
|
|
141 if (arcname == 0) return;
|
|
|
142 /* ファイル数を得る */
|
|
|
143 int slen = CheckFileDeal();
|
|
|
144 /* ファイル名のセット */
|
|
|
145 ListupFiles(slen);
|
|
|
146 if ( (!arc_atom.empty()) && arc_atom[0].filename) filenames_orig = arc_atom[0].filename;
|
|
|
147 sort(arc_atom.begin(), arc_atom.end());
|
|
|
148 }
|
|
|
149 ARCFILE::~ARCFILE() {
|
|
|
150 if (filenames_orig) delete[] filenames_orig;
|
|
|
151 delete[] arcname;
|
|
|
152 }
|
|
|
153
|
|
|
154 ARCFILE::iterator ARCFILE::SearchName(const char* f, const char* ext) {
|
|
|
155 char buf[1024]; char buf_ext[1024];
|
|
|
156 iterator it;
|
|
|
157 Init();
|
|
|
158 if (f == 0) return arc_atom.end();
|
|
|
159 if (arc_atom.empty()) return arc_atom.end();
|
|
|
160 /* エラーチェック */
|
|
|
161 if (strlen(f)>500) return arc_atom.end();
|
|
|
162 if (ext && strlen(ext)>500) return arc_atom.end();
|
|
|
163
|
|
|
164 /* 検索 */
|
|
|
165 strncpy(buf, f, 1000);
|
|
|
166 buf[1000]=0;
|
|
|
167 it = lower_bound(arc_atom.begin(), arc_atom.end(), (char*)buf);
|
|
|
168 if (it != arc_atom.end() && strcmp(it->filename_lower, buf) == 0) return it;
|
|
|
169 // 拡張子をつけて検索
|
|
|
170 if (ext) {
|
|
|
171 strcpy(buf_ext, buf);
|
|
|
172 char* ext_pt = strrchr(buf_ext, '.');
|
|
|
173 if (ext_pt == 0 || ext_pt == buf_ext) ext_pt = buf_ext + strlen(buf_ext);
|
|
|
174 *ext_pt++ = '.';
|
|
|
175 while(*ext=='.') ext++;
|
|
|
176 strcat(buf_ext, ext);
|
|
|
177 it = lower_bound(arc_atom.begin(), arc_atom.end(), (char*)buf_ext);
|
|
|
178 if (it != arc_atom.end() && strcmp(it->filename_lower, buf_ext) == 0) return it;
|
|
|
179 }
|
|
|
180
|
|
|
181 /* 小文字にして 検索 */
|
|
|
182 int i; int l = strlen(f);
|
|
|
183 if (l > 500) l = 500;
|
|
|
184 for (i=0; i<l; i++)
|
|
|
185 buf[i] = tolower(f[i]);
|
|
|
186 buf[i++] = 0;
|
|
|
187 it = lower_bound(arc_atom.begin(), arc_atom.end(), (char*)buf);
|
|
|
188 if (it != arc_atom.end() && strcmp(it->filename_lower, buf) == 0) return it;
|
|
|
189
|
|
|
190 // 拡張子をつけて検索
|
|
|
191 if (ext == 0) return arc_atom.end();
|
|
|
192 strcpy(buf_ext, buf);
|
|
|
193 char* ext_pt = strrchr(buf_ext, '.');
|
|
|
194 if (ext_pt == 0 || ext_pt == buf_ext) ext_pt = buf_ext + strlen(buf_ext);
|
|
|
195 *ext_pt++ = '.';
|
|
|
196 /* 拡張子の長さを得る */
|
|
|
197 l = strlen(ext);
|
|
|
198 for (i=0; i<l; i++)
|
|
|
199 ext_pt[i] = tolower(*ext++);
|
|
|
200 ext_pt[i] = 0;
|
|
|
201 it = lower_bound(arc_atom.begin(), arc_atom.end(), (char*)buf_ext);
|
|
|
202 if (it != arc_atom.end() && strcmp(it->filename_lower, buf_ext) == 0) return it;
|
|
|
203 return arc_atom.end();
|
|
|
204 }
|
|
|
205
|
|
|
206 ARCINFO* ARCFILE::Find(const char* fname, const char* ext) {
|
|
|
207 Init();
|
|
|
208 iterator atom = SearchName(fname,ext);
|
|
|
209 if (atom == arc_atom.end()) {
|
|
|
210 if (next) return next->Find(fname, ext);
|
|
|
211 else return 0;
|
|
|
212 }
|
|
|
213 return MakeARCINFO(*atom);
|
|
|
214 }
|
|
|
215 ARCINFO* ARCFILE::MakeARCINFO(ARCFILE_ATOM& atom) {
|
|
|
216 if (atom.arcsize == atom.filesize)
|
|
|
217 return new ARCINFO(arcname, atom);
|
|
|
218 else // 圧縮付
|
|
|
219 return new ARCINFO_AVG32(arcname, atom);
|
|
|
220 }
|
|
|
221 ARCINFO* NULFILE::MakeARCINFO(ARCFILE_ATOM& atom) {
|
|
|
222 fprintf(stderr,"NULFILE::MakeARCINFO is invalid call!\n");
|
|
|
223 return 0;
|
|
|
224 }
|
|
|
225 ARCINFO* SCN2kFILE::MakeARCINFO(ARCFILE_ATOM& atom) {
|
|
|
226 return new ARCINFO2k(arcname, atom);
|
|
|
227 }
|
|
|
228 ARCINFO* DIRFILE::MakeARCINFO(ARCFILE_ATOM& atom) {
|
|
|
229 char* name = atom.filename;
|
|
|
230 char* new_path = new char[strlen(arcname)+strlen(name)+1];
|
|
|
231 strcpy(new_path,arcname); strcat(new_path, name);
|
|
|
232 ARCINFO* ret = new ARCINFO(new_path, atom);
|
|
|
233 delete[] new_path;
|
|
|
234 return ret;
|
|
|
235 }
|
|
|
236
|
|
|
237 FILE* DIRFILE::Open(const char* fname) {
|
|
|
238 iterator atom = SearchName(fname);
|
|
|
239 if (atom == arc_atom.end()) return 0;
|
|
|
240 char* name = atom->filename;
|
|
|
241 // make FILE*
|
|
|
242 char* new_path = new char[strlen(arcname)+strlen(name)+1];
|
|
|
243 strcpy(new_path,arcname); strcat(new_path, name);
|
|
|
244 FILE* ret = fopen(new_path, "rb+");
|
|
|
245 fseek(ret, 0, 0);
|
|
|
246 delete[] new_path;
|
|
|
247 return ret;
|
|
|
248 }
|
|
|
249
|
|
|
250 char* DIRFILE::SearchFile(const char* fname) {
|
|
|
251 iterator atom = SearchName(fname);
|
|
|
252 if (atom == arc_atom.end()) return 0;
|
|
|
253 char* name = atom->filename;
|
|
|
254 char* new_path = new char[strlen(arcname)+strlen(name)+1];
|
|
|
255 strcpy(new_path,arcname); strcat(new_path, name);
|
|
|
256 struct stat sb;
|
|
|
257 if (stat(new_path, &sb) == 0 &&
|
|
|
258 ( (sb.st_mode&S_IFMT) == S_IFREG ||
|
|
|
259 (sb.st_mode&S_IFMT) == S_IFDIR)) {
|
|
|
260 return new_path;
|
|
|
261 }
|
|
|
262 delete[] new_path;
|
|
|
263 return 0;
|
|
|
264 }
|
|
|
265
|
|
|
266 void ARCFILE::ListFiles(FILE* out) {
|
|
|
267 int i;
|
|
|
268 Init();
|
|
|
269 if (arc_atom.empty()) return;
|
|
|
270 // list file name...
|
|
|
271 fprintf(out,"%16s %10s %10s %10s\n", "Filename",
|
|
|
272 "pointer","arcsize", "filesize");
|
|
|
273 vector<ARCFILE_ATOM>::iterator it;
|
|
|
274 for (it=arc_atom.begin(); it!=arc_atom.end(); it++) {
|
|
|
275 fprintf(out,"%16s %10d %10d %10d\n",
|
|
|
276 it->filename,it->offset,it->arcsize,it->filesize);
|
|
|
277 }
|
|
|
278 return;
|
|
|
279 }
|
|
|
280
|
|
|
281 void ARCFILE::InitList(void) {
|
|
|
282 Init();
|
|
|
283 list_point = 0;
|
|
|
284 }
|
|
|
285 char* ARCFILE::ListItem(void) {
|
|
|
286 if (list_point < 0) return 0;
|
|
|
287 if (list_point >= arc_atom.size()) return 0;
|
|
|
288 char* fname = arc_atom[list_point].filename;
|
|
|
289 if (fname == 0) return 0;
|
|
|
290 char* ret = new char[strlen(fname)+1];
|
|
|
291 strcpy(ret, fname);
|
|
|
292 list_point++;
|
|
|
293 return ret;
|
|
|
294 }
|
|
|
295
|
|
|
296 int ARCFILE::CheckFileDeal(void) {
|
|
|
297 char buf[0x20];
|
|
|
298 /* ヘッダのチェック */
|
|
|
299 FILE* stream = fopen(arcname, "rb");
|
|
|
300 if (stream == 0) {
|
|
|
301 fprintf(stderr, "Cannot open archive file : %s\n",arcname);
|
|
|
302 return 0;
|
|
|
303 }
|
|
|
304 fseek(stream, 0, 2); size_t arc_size = ftell(stream);
|
|
|
305 fseek(stream, 0, 0);
|
|
|
306 if (arc_size < 0x20) {
|
|
|
307 fclose(stream);
|
|
|
308 return 0;
|
|
|
309 }
|
|
|
310 fread(buf, 0x20, 1, stream);
|
|
|
311 if (strncmp(buf, "PACL", 4) != 0) {
|
|
|
312 fclose(stream);
|
|
|
313 return 0;
|
|
|
314 }
|
|
|
315 int len = read_little_endian_int(buf+0x10);
|
|
|
316 if (arc_size < size_t(0x20 + len*0x20)) {
|
|
|
317 fclose(stream);
|
|
|
318 return 0;
|
|
|
319 }
|
|
|
320 int i; int slen = 0;
|
|
|
321 for (i=0; i<len; i++) {
|
|
|
322 fread(buf, 0x20, 1, stream);
|
|
|
323 slen += strlen(buf)+1;
|
|
|
324 }
|
|
|
325 fclose(stream);
|
|
|
326 return slen;
|
|
|
327 }
|
|
|
328 void ARCFILE::ListupFiles(int fname_len) {
|
|
|
329 int i; char fbuf[0x20];
|
|
|
330 fname_len *= 2;
|
|
|
331 char* buf = new char[fname_len];
|
|
|
332 FILE* stream = fopen(arcname, "rb");
|
|
|
333 if (stream == 0) {
|
|
|
334 fprintf(stderr, "Cannot open archive file : %s\n",arcname);
|
|
|
335 return;
|
|
|
336 }
|
|
|
337 fread(fbuf,0x20,1,stream);
|
|
|
338 int len = read_little_endian_int(fbuf+0x10);
|
|
|
339 ARCFILE_ATOM atom;
|
|
|
340 for (i=0; i<len; i++) {
|
|
|
341 fread(fbuf, 0x20, 1, stream);
|
|
|
342 int l = strlen(fbuf);
|
|
|
343 if (l*2+2 > fname_len) {
|
|
|
344 break;
|
|
|
345 }
|
|
|
346 atom.offset = read_little_endian_int(fbuf+0x10);
|
|
|
347 atom.arcsize = read_little_endian_int(fbuf+0x14);
|
|
|
348 atom.filesize = read_little_endian_int(fbuf+0x18);
|
|
|
349 int j; for (j=0; j<l; j++) {
|
|
|
350 buf[j] = fbuf[j];
|
|
|
351 buf[j+l+1] = tolower(fbuf[j]);
|
|
|
352 }
|
|
|
353 buf[j] = buf[j+l+1] = 0;
|
|
|
354 atom.filename = buf;
|
|
|
355 atom.filename_lower = buf+l+1;
|
|
|
356 arc_atom.push_back(atom);
|
|
|
357 buf += l*2+2; fname_len -= l*2+2;
|
|
|
358 }
|
|
|
359 fclose(stream);
|
|
|
360 return;
|
|
|
361 }
|
|
|
362 int DIRFILE::CheckFileDeal(void) {
|
|
|
363 DIR* dir; struct dirent* ent;
|
|
|
364 int flen = 0;
|
|
|
365 dir = opendir(arcname);
|
|
|
366 if (dir == 0) {
|
|
|
367 fprintf(stderr, "Cannot open dir file : %s\n",arcname);
|
|
|
368 return 0;
|
|
|
369 }
|
|
|
370 int count = 0;
|
|
|
371 while( (ent = readdir(dir)) != NULL) {
|
|
|
372 count++;
|
|
|
373 flen += strlen(ent->d_name)+1;
|
|
|
374 }
|
|
|
375 closedir(dir);
|
|
|
376 return flen;
|
|
|
377 }
|
|
|
378 void DIRFILE::ListupFiles(int fname_len) {
|
|
|
379 DIR* dir; int i;
|
|
|
380 fname_len *= 2;
|
|
|
381 dir = opendir(arcname);
|
|
|
382 if (dir == 0) {
|
|
|
383 fprintf(stderr, "Cannot open dir file : %s\n",arcname);
|
|
|
384 return;
|
|
|
385 }
|
|
|
386 /* 一時的に arcname のディレクトリに移動する */
|
|
|
387 int old_dir_fd = open(".",O_RDONLY);
|
|
|
388 if (old_dir_fd < 0) {
|
|
|
389 closedir(dir);
|
|
|
390 return;
|
|
|
391 }
|
|
|
392 if (chdir(arcname) != 0) {
|
|
|
393 fprintf(stderr, "Cannot open dir file : %s\n",arcname);
|
|
|
394 closedir(dir);
|
|
|
395 close(old_dir_fd);
|
|
|
396 return;
|
|
|
397 };
|
|
|
398
|
|
|
399 char* buf = new char[fname_len];
|
|
|
400 ARCFILE_ATOM atom;
|
|
|
401 struct stat sb;
|
|
|
402 struct dirent* ent;
|
|
|
403 while( (ent = readdir(dir)) != NULL) {
|
|
|
404 if (stat(ent->d_name, &sb) == -1) continue;
|
|
|
405 if ( (sb.st_mode & S_IFMT) == S_IFREG) {
|
|
|
406 atom.offset = 0;
|
|
|
407 atom.arcsize = sb.st_size;
|
|
|
408 atom.filesize = sb.st_size;
|
|
|
409 } else if ( (sb.st_mode & S_IFMT) == S_IFDIR) {
|
|
|
410 atom.offset = 0;
|
|
|
411 atom.arcsize = atom.filesize = 0;
|
|
|
412 } else {
|
|
|
413 continue;
|
|
|
414 }
|
|
|
415 int l = strlen(ent->d_name);
|
|
|
416 if (l*2+2 > fname_len) {
|
|
|
417 break;
|
|
|
418 }
|
|
|
419 int j; for (j=0; j<l+1; j++) {
|
|
|
420 buf[j] = ent->d_name[j];
|
|
|
421 buf[j+l+1] = tolower(ent->d_name[j]);
|
|
|
422 }
|
|
|
423 atom.filename = buf; atom.filename_lower = buf+l+1;
|
|
|
424 arc_atom.push_back(atom);
|
|
|
425 buf += l*2+2; fname_len -= l*2+2;
|
|
|
426 }
|
|
|
427 /* chdir() したのを元に戻る */
|
|
|
428 closedir(dir);
|
|
|
429 fchdir(old_dir_fd); close(old_dir_fd);
|
|
|
430 return;
|
|
|
431 }
|
|
|
432 int NULFILE::CheckFileDeal(void) {
|
|
|
433 return 20;
|
|
|
434 }
|
|
|
435 void NULFILE::ListupFiles(int fname_len) {
|
|
|
436 char* s = new char[40];
|
|
|
437 ARCFILE_ATOM atom;
|
|
|
438 atom.offset = 0; atom.arcsize = 0; atom.filesize = 0;
|
|
|
439 strcpy(s, "** null dummy **");
|
|
|
440 atom.filename = s;
|
|
|
441 atom.filename_lower = s;
|
|
|
442 arc_atom.push_back(atom);
|
|
|
443 }
|
|
|
444 int SCN2kFILE::CheckFileDeal(void) {
|
|
|
445 /* ヘッダのチェック */
|
|
|
446 FILE* stream = fopen(arcname, "rb");
|
|
|
447 if (stream == 0) {
|
|
|
448 fprintf(stderr, "Cannot open archive file : %s\n",arcname);
|
|
|
449 return 0;
|
|
|
450 }
|
|
|
451 fseek(stream, 0, 2); size_t arc_size = ftell(stream);
|
|
|
452 fseek(stream, 0, 0);
|
|
|
453 if (arc_size < 10000*8) {
|
|
|
454 fclose(stream);
|
|
|
455 return 0;
|
|
|
456 }
|
|
|
457 char* buf = new char[10000*8];
|
|
|
458 fread(buf, 10000, 8, stream);
|
|
|
459 /* size == 0 のデータは存在しない */
|
|
|
460 int count = 0;
|
|
|
461 int i; for (i=0; i<10000; i++) {
|
|
|
462 int tmp_offset = read_little_endian_int(buf+i*8);
|
|
|
463 int tmp_size = read_little_endian_int(buf+i*8+4);
|
|
|
464 if (tmp_size <= 0 || tmp_offset < 0 || tmp_offset+tmp_size > int(arc_size) ) continue;
|
|
|
465 count++;
|
|
|
466 }
|
|
|
467 fclose(stream);
|
|
|
468 delete[] buf;
|
|
|
469 return count*13; /* ファイル名は seenXXXX.txt だから、一つ12文字+null */
|
|
|
470 }
|
|
|
471 void SCN2kFILE::ListupFiles(int fname_len) {
|
|
|
472 FILE* stream = fopen(arcname, "rb");
|
|
|
473 if (stream == 0) {
|
|
|
474 fprintf(stderr, "Cannot open archive file : %s\n",arcname);
|
|
|
475 return;
|
|
|
476 }
|
|
|
477 char* sbuf = new char[fname_len];
|
|
|
478 char* buf = new char[10000*8];
|
|
|
479 fread(buf, 10000, 8, stream);
|
|
|
480 fseek(stream, 0, 2); size_t arc_size = ftell(stream);
|
|
|
481 ARCFILE_ATOM atom;
|
|
|
482 int i; for (i=0; i<10000; i++) {
|
|
|
483 char header[0x200];
|
|
|
484 int tmp_offset = read_little_endian_int(buf+i*8);
|
|
|
485 int tmp_size = read_little_endian_int(buf+i*8+4);
|
|
|
486 if (tmp_size <= 0 || tmp_offset < 0 || tmp_offset+tmp_size > int(arc_size) ) continue;
|
|
|
487 /* header を得て圧縮形式などを調べる */
|
|
|
488 fseek(stream, tmp_offset, 0);
|
|
|
489 fread(header, 0x200, 1, stream);
|
|
|
490 int header_top = read_little_endian_int(header+0);
|
|
|
491 int file_version = read_little_endian_int(header+4);
|
|
|
492
|
|
|
493 if (file_version == 0x1adb2) ; // Little Busters!
|
|
|
494 else if (file_version != 0x2712) continue; /* system version が違う */
|
|
|
495
|
|
|
496 if (header_top == 0x1cc) { /* 古い形式 : avg2000 */
|
|
|
497 int header_size = read_little_endian_int(header+0)+read_little_endian_int(header+0x20)*4;
|
|
|
498 int data_size = read_little_endian_int(header+0x24);
|
|
|
499 atom.arcsize = data_size + header_size;
|
|
|
500 atom.filesize = data_size + header_size;
|
|
|
501 atom.private_data = header_size;
|
|
|
502
|
|
|
503 } else if (header_top == 0x1b8) { /* 初夜献上 */
|
|
|
504 int header_size = read_little_endian_int(header+0)+read_little_endian_int(header+0x08)*4;
|
|
|
505 int data_size = read_little_endian_int(header+0x0c);
|
|
|
506 int compdata_size = read_little_endian_int(header+0x10);
|
|
|
507 atom.arcsize = compdata_size + header_size;
|
|
|
508 atom.filesize = data_size + header_size;
|
|
|
509 atom.private_data = header_size;
|
|
|
510
|
|
|
511 } else if (header_top == 0x1d0) { /* 新しい形式： reallive */
|
|
|
512 int header_size = read_little_endian_int(header+0x20);
|
|
|
513 int data_size = read_little_endian_int(header+0x24);
|
|
|
514 int compdata_size = read_little_endian_int(header+0x28);
|
|
|
515 atom.arcsize = compdata_size + header_size;
|
|
|
516 atom.filesize = data_size + header_size;
|
|
|
517 atom.private_data = header_size;
|
|
|
518 } else {
|
|
|
519 fprintf(stderr,"invalid header top; %x : not supported\n",header_top);
|
|
|
520 continue; /* サポートしない形式 */
|
|
|
521 }
|
|
|
522
|
|
|
523 atom.offset = tmp_offset;
|
|
|
524 atom.filename = sbuf;
|
|
|
525 atom.filename_lower = sbuf;
|
|
|
526 arc_atom.push_back(atom);
|
|
|
527 sprintf(sbuf, "seen%04d.txt",i); sbuf += 13;
|
|
|
528 }
|
|
7
|
529 delete[] buf;
|
|
0
|
530 fclose(stream);
|
|
|
531 return;
|
|
|
532 }
|
|
|
533
|
|
|
534 /********************************************************
|
|
|
535 ** FILESEARCH クラスの実装
|
|
|
536 */
|
|
|
537
|
|
|
538 FILESEARCH::FILESEARCH(void) {
|
|
|
539 int i;
|
|
|
540 root_dir = 0; dat_dir = 0;
|
|
|
541 for (i=0; i<TYPEMAX; i++) {
|
|
|
542 searcher[i] = 0;
|
|
|
543 filenames[i] = default_dirnames[i];
|
|
|
544 is_archived[i] = default_is_archived[i];
|
|
|
545 }
|
|
|
546 }
|
|
|
547 FILESEARCH::~FILESEARCH(void) {
|
|
|
548 int i;
|
|
|
549 for (i=0; i<TYPEMAX; i++) {
|
|
|
550 if (filenames[i] != 0 && filenames[i] != default_dirnames[i]) delete[] filenames[i];
|
|
|
551 if (searcher[i] && searcher[i] != dat_dir && searcher[i] != root_dir) {
|
|
|
552 delete searcher[i];
|
|
|
553 }
|
|
|
554 }
|
|
|
555 if (dat_dir && dat_dir != root_dir) delete dat_dir;
|
|
|
556 if (root_dir) delete root_dir;
|
|
|
557 }
|
|
|
558
|
|
|
559 int FILESEARCH::InitRoot(char* root) {
|
|
|
560 /* 必要に応じて ~/ を展開 */
|
|
|
561 if (root[0] == '~' && root[1] == '/') {
|
|
|
562 char* home = getenv("HOME");
|
|
|
563 if (home != 0) {
|
|
|
564 char* new_root = new char[strlen(home)+strlen(root)];
|
|
|
565 strcpy(new_root, home);
|
|
|
566 strcat(new_root, root+1);
|
|
|
567 root = new_root;
|
|
|
568 }
|
|
|
569 }
|
|
|
570 /* 古いデータを消す */
|
|
|
571 int i;
|
|
|
572 for (i=0; i<TYPEMAX; i++) {
|
|
|
573 if (searcher[i] != 0 &&
|
|
|
574 searcher[i] != root_dir &&
|
|
|
575 searcher[i] != dat_dir) {
|
|
|
576 delete searcher[i];
|
|
|
577 }
|
|
|
578 searcher[i] = 0;
|
|
|
579 }
|
|
|
580 if (dat_dir && root_dir != dat_dir) delete dat_dir;
|
|
|
581 if (root_dir) delete root_dir;
|
|
|
582 dat_dir = 0;
|
|
|
583
|
|
|
584 /* 新しいディレクトリのもとで初期化 */
|
|
|
585 root_dir = new DIRFILE(root);
|
|
|
586 root_dir->Init();
|
|
|
587 /* dat/ を検索 */
|
|
|
588 char* dat_path = root_dir->SearchFile("dat");
|
|
|
589 if (dat_path == 0) {
|
|
|
590 /* 見つからなかったら root を dat の代わりにつかう */
|
|
|
591 dat_dir = root_dir;
|
|
|
592 } else {
|
|
|
593 dat_dir = new DIRFILE(dat_path);
|
|
|
594 dat_dir->Init();
|
|
|
595 }
|
|
|
596 searcher[ALL] = dat_dir;
|
|
|
597 searcher[ROOT] = root_dir;
|
|
|
598 return 0;
|
|
|
599 }
|
|
|
600
|
|
|
601 void FILESEARCH::SetFileInformation(FILETYPE tp, ARCTYPE is_arc, char* filename) {
|
|
|
602 int type = tp;
|
|
|
603 if (type < 0 || type >= TYPEMAX) return;
|
|
|
604 ARCFILE* next_arc = 0;
|
|
|
605 /* すでに searcher が存在すれば解放 */
|
|
|
606 if (searcher[type] != 0 &&
|
|
|
607 searcher[type] != root_dir &&
|
|
|
608 searcher[type] != dat_dir) {
|
|
|
609 next_arc = searcher[type]->Next();
|
|
|
610 delete searcher[type];
|
|
|
611 }
|
|
|
612 searcher[type] = 0;
|
|
|
613 /* 適当に初期化 */
|
|
|
614 if (filenames[type] != 0 &&
|
|
|
615 filenames[type] != default_dirnames[type]) delete[] filenames[type];
|
|
|
616 filenames[type] = new char[strlen(filename)+1];
|
|
|
617 strcpy(filenames[type], filename);
|
|
|
618 is_archived[type] = is_arc;
|
|
|
619 searcher[type] = MakeARCFILE(is_arc, filename);
|
|
|
620 if (searcher[type] && next_arc)
|
|
|
621 searcher[type]->SetNext(next_arc);
|
|
|
622 return;
|
|
|
623 }
|
|
|
624 void FILESEARCH::AppendFileInformation(FILETYPE tp, ARCTYPE is_arc, char* filename) {
|
|
|
625 int type = tp;
|
|
|
626 if (type < 0 || type >= TYPEMAX) return;
|
|
|
627 /* searcher がまだ割り当てられてない場合 */
|
|
|
628 if (searcher[type] == 0 ||
|
|
|
629 searcher[type] == root_dir ||
|
|
|
630 searcher[type] == dat_dir) {
|
|
|
631 searcher[type] = MakeARCFILE(is_archived[type], filenames[type]);
|
|
|
632 if (searcher[type] == 0) { /* 作成できなかった場合 */
|
|
|
633 /* この型情報を FileInformation とする */
|
|
|
634 SetFileInformation(tp, is_arc, filename);
|
|
|
635 return;
|
|
|
636 }
|
|
|
637 }
|
|
|
638 /* 初期化 */
|
|
|
639 ARCFILE* arc = MakeARCFILE(is_arc, filename);
|
|
|
640 /* append */
|
|
|
641 ARCFILE* cur;
|
|
|
642 for (cur=searcher[type]; cur->Next() != 0; cur = cur->Next()) ;
|
|
|
643 cur->SetNext(arc);
|
|
|
644 return;
|
|
|
645 }
|
|
|
646
|
|
|
647 ARCFILE* FILESEARCH::MakeARCFILE(ARCTYPE tp, char* filename) {
|
|
|
648 ARCFILE* arc = 0;
|
|
|
649 char* file;
|
|
|
650 if (filename == 0) goto err;
|
|
|
651 if (tp == ATYPE_DIR) {
|
|
|
652 file = root_dir->SearchFile(filename);
|
|
|
653 } else {
|
|
|
654 file = dat_dir->SearchFile(filename);
|
|
|
655 if (file == 0)
|
|
|
656 file = root_dir->SearchFile(filename);
|
|
|
657 }
|
|
|
658 if (file == 0) goto err;
|
|
|
659 switch(tp) {
|
|
|
660 case ATYPE_DIR: arc = new DIRFILE(file); break;
|
|
|
661 case ATYPE_SCN2k:
|
|
|
662 case ATYPE_ARC: {
|
|
|
663 FILE* f = fopen(file, "rb");
|
|
|
664 if (f == 0) goto err;
|
|
|
665 char header[32];
|
|
|
666 memset(header, 0, 32);
|
|
|
667 fread(header, 32, 1, f);
|
|
|
668 fclose(f);
|
|
|
669 char magic_raf[8] = {'C','A','P','F',1,0,0,0};
|
|
|
670 if (strncmp(header, "PACL", 4) == 0) arc = new ARCFILE(file);
|
|
|
671 else arc = new SCN2kFILE(file);
|
|
|
672 }
|
|
|
673 break;
|
|
|
674 default: fprintf(stderr,"FILESEARCH::MAKEARCFILE : invalid archive type; type %d name %s\n",tp,filename);
|
|
|
675 delete[] file;
|
|
|
676 goto err;
|
|
|
677 }
|
|
|
678 delete[] file;
|
|
|
679 return arc;
|
|
|
680 err:
|
|
|
681 arc = new NULFILE;
|
|
|
682 return arc;
|
|
|
683
|
|
|
684 }
|
|
|
685
|
|
|
686 ARCINFO* FILESEARCH::Find(FILETYPE type, const char* fname, const char* ext) {
|
|
|
687 if (searcher[type] == 0) {
|
|
|
688 /* searcher 作成 */
|
|
|
689 if (filenames[type] == 0) {
|
|
|
690 searcher[type] = dat_dir;
|
|
|
691 } else {
|
|
|
692 searcher[type] = MakeARCFILE(is_archived[type], filenames[type]);
|
|
|
693 if (searcher[type] == 0) {
|
|
|
694 fprintf(stderr,"FILESEARCH::Find : invalid archive type; type %d name %s\n",type,fname);
|
|
|
695 return 0;
|
|
|
696 }
|
|
|
697 }
|
|
|
698 }
|
|
|
699 return searcher[type]->Find(fname,ext);
|
|
|
700 }
|
|
|
701
|
|
|
702 char** FILESEARCH::ListAll(FILETYPE type) {
|
|
|
703 int i;
|
|
|
704 /* とりあえず searcher を初期化 */
|
|
|
705 Find(type, "THIS FILENAME MAY NOT EXIST IN THE FILE SYSTEM !!!");
|
|
|
706 if (searcher[type] == 0) return 0;
|
|
|
707 /* 全ファイルのリストアップ */
|
|
|
708 int deal = 0;
|
|
|
709 ARCFILE* file;
|
|
|
710 for (file = searcher[type]; file != 0; file = file->Next())
|
|
|
711 deal += file->Deal();
|
|
|
712 if (deal <= 0) return 0;
|
|
|
713 char** ret_list = new char*[deal+1];
|
|
|
714 int count = 0;
|
|
|
715 for (file = searcher[type]; file != 0; file = file->Next()) {
|
|
|
716 file->InitList();
|
|
|
717 char* f;
|
|
|
718 while( (f = file->ListItem() ) != 0) {
|
|
|
719 ret_list[count] = new char[strlen(f)+1];
|
|
|
720 strcpy(ret_list[count], f);
|
|
|
721 count++;
|
|
|
722 }
|
|
|
723 }
|
|
|
724 ret_list[count] = 0;
|
|
|
725 return ret_list;
|
|
|
726 }
|
|
|
727
|
|
|
728 ARCINFO::ARCINFO(const char* __arcname, ARCFILE_ATOM& atom) : info(atom) {
|
|
|
729 arcfile = new char[strlen(__arcname)+1];
|
|
|
730 strcpy(arcfile, __arcname);
|
|
|
731 use_mmap = false;
|
|
|
732 mmapped_memory = 0;
|
|
|
733 data = 0;
|
|
|
734 fd = -1;
|
|
|
735 }
|
|
|
736
|
|
|
737 ARCINFO::~ARCINFO() {
|
|
|
738 #ifdef HAVE_MMAP
|
|
|
739 if (mmapped_memory) munmap(mmapped_memory, info.arcsize);
|
|
|
740 #endif /* HAVE_MMAP */
|
|
|
741 if (fd != -1) close(fd);
|
|
|
742 if (data != mmapped_memory) delete[] data;
|
|
|
743 delete[] arcfile;
|
|
|
744 }
|
|
|
745
|
|
|
746 int ARCINFO::Size(void) const {
|
|
|
747 return info.filesize;
|
|
|
748 }
|
|
|
749
|
|
|
750 /* コピーを返す */
|
|
|
751 char* ARCINFO::CopyRead(void) {
|
|
|
752 const char* d = Read();
|
|
|
753 if (d == 0) return 0;
|
|
|
754 int s = Size();
|
|
|
755 if (s <= 0) return 0;
|
|
|
756 char* ret = new char[s]; memcpy(ret, d, s);
|
|
|
757 return ret;
|
|
|
758 }
|
|
|
759
|
|
|
760 const char* ARCINFO::Path(void) const {
|
|
|
761 if (info.offset != 0) return 0; /* archive file なのでパスを帰せない */
|
|
|
762 char* ret = new char[strlen(arcfile)+1];
|
|
|
763 strcpy(ret, arcfile);
|
|
|
764 return ret;
|
|
|
765 }
|
|
|
766 /* 互換性専用 */
|
|
|
767 FILE* ARCINFO::OpenFile(int* length) const {
|
|
|
768 FILE* f = fopen(arcfile, "rb");
|
|
|
769 if (info.offset) lseek(fileno(f), info.offset, SEEK_SET);
|
|
|
770 if (length) *length = info.arcsize;
|
|
|
771 return f;
|
|
|
772 }
|
|
|
773
|
|
|
774 // 展開処理はなし
|
|
|
775 bool ARCINFO::ExecExtract(void) {
|
|
|
776 return true;
|
|
|
777 }
|
|
|
778 /* 読み込みを開始する */
|
|
|
779 const char* ARCINFO::Read(void) {
|
|
|
780 // すでにデータを読み込み済みなら何もしない
|
|
|
781 if (data) return data;
|
|
|
782
|
|
|
783 if (info.offset < 0 || info.arcsize <= 0) {
|
|
|
784 return 0;
|
|
|
785 }
|
|
|
786 /* ファイルを開く */
|
|
|
787 fd = open(arcfile, O_RDONLY);
|
|
|
788 if (fd < 0) {
|
|
|
789 return 0;
|
|
|
790 }
|
|
|
791 if (lseek(fd, info.offset, 0) != info.offset) {
|
|
|
792 close(fd); fd = -1; return 0;
|
|
|
793 }
|
|
|
794 /* mmap を試みる */
|
|
|
795 #ifdef HAVE_MMAP
|
|
|
796 mmapped_memory = (char*)mmap(0, info.arcsize, PROT_READ, MAP_SHARED, fd, info.offset);
|
|
|
797 if (mmapped_memory != MAP_FAILED) {
|
|
|
798 use_mmap = true;
|
|
|
799 data = (const char*)mmapped_memory;
|
|
|
800 } else
|
|
|
801 #endif /* HAVE_MMAP */
|
|
|
802 {
|
|
|
803 /* 失敗：普通にファイルを読み込み */
|
|
|
804 char* d = new char[info.arcsize];
|
|
|
805 read(fd, d, info.arcsize);
|
|
|
806 close(fd);
|
|
|
807 fd = -1;
|
|
|
808 use_mmap = false;
|
|
|
809 data = d;
|
|
|
810 }
|
|
|
811 /* 展開する */
|
|
|
812 if (! ExecExtract()) {
|
|
|
813 // 失敗
|
|
|
814 #ifdef HAVE_MMAP
|
|
|
815 if (use_mmap) {
|
|
|
816 munmap(mmapped_memory, info.arcsize);
|
|
|
817 if (data == (const char*)mmapped_memory) data = 0;
|
|
|
818 }
|
|
|
819 #endif /* HAVE_MMAP */
|
|
|
820 delete[] (char*)data;
|
|
|
821 close(fd);
|
|
|
822 fd = -1; data = 0;
|
|
|
823 return 0;
|
|
|
824 }
|
|
|
825 #ifdef HAVE_MMAP
|
|
|
826 if (use_mmap && data != (const char*)mmapped_memory) {
|
|
|
827 // すでに mmap は必要ない
|
|
|
828 munmap(mmapped_memory, info.arcsize);
|
|
|
829 close(fd);
|
|
|
830 fd = -1;
|
|
|
831 use_mmap = false;
|
|
|
832 }
|
|
|
833 #endif /* HAVE_MMAP */
|
|
|
834 return data;
|
|
|
835 }
|
|
|
836
|
|
|
837 /**********************************************
|
|
|
838 **
|
|
|
839 ** 画像展開系クラスの定義、実装
|
|
|
840 **
|
|
|
841 ***********************************************
|
|
|
842 */
|
|
|
843 GRPCONV::GRPCONV(void) {
|
|
|
844 filename = 0;
|
|
|
845 data = 0;
|
|
|
846 }
|
|
|
847 GRPCONV::~GRPCONV() {
|
|
|
848 if (filename) delete[] filename;
|
|
|
849 }
|
|
|
850 void GRPCONV::Init(const char* f, const char* d, int dlen, int w, int h, bool is_m) {
|
|
|
851 if (filename) delete[] filename;
|
|
|
852 if (f == 0) {
|
|
|
853 char* fn = new char[1];
|
|
|
854 fn[0] = 0;
|
|
|
855 filename = fn;
|
|
|
856 } else {
|
|
|
857 char* fn = new char[strlen(f)+1];
|
|
|
858 strcpy(fn,f);
|
|
|
859 filename = fn;
|
|
|
860 }
|
|
|
861
|
|
|
862 data = d;
|
|
|
863 datalen = dlen;
|
|
|
864 width = w;
|
|
|
865 height = h;
|
|
|
866 is_mask = is_m;
|
|
|
867 }
|
|
|
868 class PDTCONV : public GRPCONV {
|
|
|
869 bool Read_PDT10(char* image);
|
|
|
870 bool Read_PDT11(char* image);
|
|
|
871 public:
|
|
|
872 PDTCONV(const char* _inbuf, int inlen, const char* fname);
|
|
|
873 ~PDTCONV() {}
|
|
|
874 bool Read(char* image);
|
|
|
875 };
|
|
|
876 class G00CONV : public GRPCONV {
|
|
|
877 struct REGION {
|
|
|
878 int x1, y1, x2, y2;
|
|
|
879 int Width() { return x2-x1+1;}
|
|
|
880 int Height() { return y2-y1+1;}
|
|
|
881 void FixVar(int& v, int& w) {
|
|
|
882 if (v < 0) v = 0;
|
|
|
883 if (v >= w) v = w-1;
|
|
|
884 }
|
|
|
885 void Fix(int w, int h) {
|
|
|
886 FixVar(x1,w);
|
|
|
887 FixVar(x2,w);
|
|
|
888 FixVar(y1,h);
|
|
|
889 FixVar(y2,h);
|
|
|
890 if (x1 > x2) x2 = x1;
|
|
|
891 if (y1 > y2) y2 = y1;
|
|
|
892 }
|
|
|
893 };
|
|
|
894
|
|
|
895 void Copy_16bpp(char* image, int x, int y, const char* src, int bpl, int h);
|
|
|
896 void Copy_32bpp(char* image, int x, int y, const char* src, int bpl, int h);
|
|
|
897 bool Read_Type0(char* image);
|
|
|
898 bool Read_Type1(char* image);
|
|
|
899 bool Read_Type2(char* image);
|
|
|
900 public:
|
|
|
901 G00CONV(const char* _inbuf, int _inlen, const char* fname);
|
|
|
902 ~G00CONV() { }
|
|
|
903 bool Read(char* image);
|
|
|
904 };
|
|
|
905
|
|
|
906 class BMPCONV : public GRPCONV {
|
|
|
907 public:
|
|
|
908 BMPCONV(const char* _inbuf, int _inlen, const char* fname);
|
|
|
909 ~BMPCONV() {};
|
|
|
910 bool Read(char* image);
|
|
|
911 };
|
|
|
912 #if HAVE_LIBPNG
|
|
|
913 class PNGCONV : public GRPCONV {
|
|
|
914 const char* png_data;
|
|
|
915 static void png_read(png_structp, png_bytep, png_size_t);
|
|
|
916
|
|
|
917 public:
|
|
|
918 PNGCONV(const char* _inbuf, int _inlen, const char* fname);
|
|
|
919 ~PNGCONV() {};
|
|
|
920 bool Read(char* image);
|
|
|
921 };
|
|
|
922 #endif
|
|
|
923
|
|
|
924 #if HAVE_LIBJPEG
|
|
|
925 class JPEGCONV : public GRPCONV {
|
|
|
926
|
|
|
927 public:
|
|
|
928 JPEGCONV(const char* _inbuf, int _inlen, const char* fname);
|
|
|
929 ~JPEGCONV() {};
|
|
|
930 bool Read(char* image);
|
|
|
931 void SetupSrc(struct jpeg_decompress_struct* cinfo, const char* data, int size);
|
|
|
932 static void init_source(j_decompress_ptr cinfo);
|
|
|
933 static boolean fill_input_buffer(j_decompress_ptr cinfo);
|
|
|
934 static void skip_input_data(j_decompress_ptr cinfo, long num_bytes);
|
|
|
935 static boolean resync_to_restart(j_decompress_ptr cinfo, int desired);
|
|
|
936 static void term_source(j_decompress_ptr cinf);
|
|
|
937 };
|
|
|
938 #endif
|
|
|
939
|
|
|
940 GRPCONV* GRPCONV::AssignConverter(const char* inbuf, int inlen, const char* fname) {
|
|
|
941 /* ファイルの内容に応じたコンバーターを割り当てる */
|
|
|
942 GRPCONV* conv = 0;
|
|
|
943 if (inlen < 10) return 0; /* invalid file */
|
|
|
944 if (conv == 0 && strncmp(inbuf, "PDT10", 5) == 0 || strncmp(inbuf, "PDT11", 5) == 0) { /* PDT10 or PDT11 */
|
|
|
945 conv = new PDTCONV(inbuf, inlen, fname);
|
|
|
946 if (conv->data == 0) { delete conv; conv = 0;}
|
|
|
947 }
|
|
|
948 #if HAVE_LIBPNG
|
|
|
949 unsigned char png_magic[4] = {0x89, 'P', 'N', 'G'};
|
|
|
950 if (conv == 0 && memcmp(inbuf, png_magic,4) == 0) {
|
|
|
951 conv = new PNGCONV(inbuf, inlen, fname);
|
|
|
952 if (conv->data == 0) { delete conv; conv = 0;}
|
|
|
953 }
|
|
|
954 #endif
|
|
|
955 #if HAVE_LIBJPEG
|
|
|
956 if ( conv == 0 && *(unsigned char*)inbuf == 0xff && *(unsigned char*)(inbuf+1) == 0xd8 &&
|
|
|
957 (strncmp(inbuf+6, "JFIF",4) == 0 || strncmp(inbuf+6,"Exif",4) == 0)) {
|
|
|
958 conv = new JPEGCONV(inbuf, inlen, fname);
|
|
|
959 if (conv->data == 0) { delete conv; conv = 0;}
|
|
|
960 }
|
|
|
961 #endif
|
|
|
962 if (conv == 0 && inbuf[0]=='B' && inbuf[1]=='M' && read_little_endian_int(inbuf+10)==0x36 && read_little_endian_int(inbuf+14) == 0x28) { // Windows BMP
|
|
|
963 conv = new BMPCONV(inbuf, inlen, fname);
|
|
|
964 if (conv->data == 0) { delete conv; conv = 0;}
|
|
|
965 }
|
|
|
966 if (conv == 0 && (inbuf[0] == 0 || inbuf[0] == 1 || inbuf[0] == 2)) { /* G00 */
|
|
|
967 conv = new G00CONV(inbuf, inlen, fname);
|
|
|
968 if (conv->data == 0) { delete conv; conv = 0;}
|
|
|
969 }
|
|
|
970 return conv;
|
|
|
971 }
|
|
|
972
|
|
|
973 PDTCONV::PDTCONV(const char* _inbuf, int _inlen,const char* filename) {
|
|
|
974 // PDT FILE のヘッダ
|
|
|
975 // +00 'PDT10' (PDT11 は未対応)
|
|
|
976 // +08 ファイルサイズ (無視)
|
|
|
977 // +0C width (ほぼすべて、640)
|
|
|
978 // +10 height(ほぼすべて、480)
|
|
|
979 // +14 (mask の) x 座標 (実際は無視・・・全ファイルで 0 )
|
|
|
980 // +1c (mask の) y座標 (実際は無視 ・・・全ファイルで 0 )
|
|
|
981 // +20 mask が存在すれば、mask へのポインタ
|
|
|
982
|
|
|
983 /* ヘッダチェック */
|
|
|
984 if (_inlen < 0x20) {
|
|
|
985 fprintf(stderr, "Invalid PDT file %s : size is too small\n",filename);
|
|
|
986 return;
|
|
|
987 }
|
|
|
988 if (strncmp(_inbuf, "PDT10", 5) != 0 && strncmp(_inbuf, "PDT11", 5) != 0) {
|
|
|
989 fprintf(stderr, "Invalid PDT file %s : not 'PDT10 / PDT11' file.\n", filename);
|
|
|
990 return;
|
|
|
991 }
|
|
|
992 if (size_t(_inlen) != size_t(read_little_endian_int(_inbuf+0x08))) {
|
|
|
993 fprintf(stderr, "Invalid archive file %s : invalid header.(size)\n",
|
|
|
994 filename);
|
|
|
995 return;
|
|
|
996 }
|
|
|
997
|
|
|
998 int w = read_little_endian_int(_inbuf+0x0c);
|
|
|
999 int h = read_little_endian_int(_inbuf+0x10);
|
|
|
1000 int mask_pt = read_little_endian_int(_inbuf + 0x1c);
|
|
|
1001 Init(filename, _inbuf, _inlen, w, h, mask_pt ? true : false);
|
|
|
1002
|
|
|
1003 return;
|
|
|
1004 }
|
|
|
1005
|
|
|
1006
|
|
|
1007 G00CONV::G00CONV(const char* _inbuf, int _inlen, const char* filename) {
|
|
|
1008 // G00 FILE のヘッダ
|
|
|
1009 // +00 type (1, 2)
|
|
|
1010 // +01: width(word)
|
|
|
1011 // +03: height(word)
|
|
|
1012 // type 1: (color table 付き LZ 圧縮 ; PDT11 に対応)
|
|
|
1013 // +05: 圧縮サイズ(dword) ; +5 するとデータ全体のサイズ
|
|
|
1014 // +09: 展開後サイズ(dword)
|
|
|
1015 // type 2: (マスク可、画像を矩形領域に分割してそれぞれ圧縮)
|
|
|
1016 // +05: index size
|
|
|
1017 // +09: index table(each size is 0x18)
|
|
|
1018 // +00
|
|
|
1019 //
|
|
|
1020 // +09+0x18*size+00: data size
|
|
|
1021 // +09+0x18*size+04: out size
|
|
|
1022 // +09+0x18*size+08: (data top)
|
|
|
1023 //
|
|
|
1024
|
|
|
1025 /* データから情報読み込み */
|
|
|
1026 int type = *_inbuf;
|
|
|
1027
|
|
|
1028 int w = read_little_endian_short(_inbuf+1);
|
|
|
1029 int h = read_little_endian_short(_inbuf+3);
|
|
|
1030 if (w < 0 || h < 0) return;
|
|
|
1031
|
|
|
1032 if (type == 0 || type == 1) { // color table 付き圧縮
|
|
|
1033 if (_inlen < 13) {
|
|
|
1034 fprintf(stderr, "Invalid G00 file %s : size is too small\n",filename);
|
|
|
1035 return;
|
|
|
1036 }
|
|
|
1037 int data_sz = read_little_endian_int(_inbuf+5);
|
|
|
1038
|
|
|
1039 if (_inlen != data_sz+5) {
|
|
|
1040 fprintf(stderr, "Invalid archive file %s : invalid header.(size)\n",
|
|
|
1041 filename);
|
|
|
1042 return;
|
|
|
1043 }
|
|
|
1044 Init(filename, _inbuf, _inlen, w, h, false);
|
|
|
1045 } else if (type == 2) { // color table なし、マスク付き可の圧縮
|
|
|
1046
|
|
|
1047 int head_size = read_little_endian_short(_inbuf+5);
|
|
|
1048 if (head_size < 0 || head_size*24 > _inlen) return;
|
|
|
1049
|
|
|
1050 const char* data_top = _inbuf + 9 + head_size*24;
|
|
|
1051 int data_sz = read_little_endian_int(data_top);
|
|
|
1052 if (_inbuf + _inlen != data_top + data_sz) {
|
|
|
1053 fprintf(stderr, "Invalid archive file %s : invalid header.(size)\n",
|
|
|
1054 filename);
|
|
|
1055 return;
|
|
|
1056 }
|
|
|
1057 Init(filename, _inbuf, _inlen, w, h, true);
|
|
|
1058 }
|
|
|
1059 return;
|
|
|
1060 }
|
|
|
1061
|
|
|
1062 bool G00CONV::Read(char* image) {
|
|
|
1063 if (data == 0) return false;
|
|
|
1064 /* header 識別 */
|
|
|
1065 int type = *data;
|
|
|
1066 if (type == 0) return Read_Type0(image);
|
|
|
1067 else if (type == 1) return Read_Type1(image);
|
|
|
1068 else if (type == 2) return Read_Type2(image);
|
|
|
1069 }
|
|
|
1070
|
|
|
1071 /* 一般的な LZ 圧縮の展開ルーチン */
|
|
|
1072 /* datasize はデータの大きさ、char / short / int を想定 */
|
|
|
1073 /* datatype は Copy1Pixel (1データのコピー)及び ExtractData(LZ 圧縮の情報を得る
|
|
|
1074 ** というメソッドを実装したクラス */
|
|
|
1075 static int bitrev_table[256] = {
|
|
|
1076 0x00, 0x80, 0x40, 0xc0, 0x20, 0xa0, 0x60, 0xe0, 0x10, 0x90, 0x50, 0xd0, 0x30, 0xb0, 0x70, 0xf0,
|
|
|
1077 0x08, 0x88, 0x48, 0xc8, 0x28, 0xa8, 0x68, 0xe8, 0x18, 0x98, 0x58, 0xd8, 0x38, 0xb8, 0x78, 0xf8,
|
|
|
1078 0x04, 0x84, 0x44, 0xc4, 0x24, 0xa4, 0x64, 0xe4, 0x14, 0x94, 0x54, 0xd4, 0x34, 0xb4, 0x74, 0xf4,
|
|
|
1079 0x0c, 0x8c, 0x4c, 0xcc, 0x2c, 0xac, 0x6c, 0xec, 0x1c, 0x9c, 0x5c, 0xdc, 0x3c, 0xbc, 0x7c, 0xfc,
|
|
|
1080 0x02, 0x82, 0x42, 0xc2, 0x22, 0xa2, 0x62, 0xe2, 0x12, 0x92, 0x52, 0xd2, 0x32, 0xb2, 0x72, 0xf2,
|
|
|
1081 0x0a, 0x8a, 0x4a, 0xca, 0x2a, 0xaa, 0x6a, 0xea, 0x1a, 0x9a, 0x5a, 0xda, 0x3a, 0xba, 0x7a, 0xfa,
|
|
|
1082 0x06, 0x86, 0x46, 0xc6, 0x26, 0xa6, 0x66, 0xe6, 0x16, 0x96, 0x56, 0xd6, 0x36, 0xb6, 0x76, 0xf6,
|
|
|
1083 0x0e, 0x8e, 0x4e, 0xce, 0x2e, 0xae, 0x6e, 0xee, 0x1e, 0x9e, 0x5e, 0xde, 0x3e, 0xbe, 0x7e, 0xfe,
|
|
|
1084 0x01, 0x81, 0x41, 0xc1, 0x21, 0xa1, 0x61, 0xe1, 0x11, 0x91, 0x51, 0xd1, 0x31, 0xb1, 0x71, 0xf1,
|
|
|
1085 0x09, 0x89, 0x49, 0xc9, 0x29, 0xa9, 0x69, 0xe9, 0x19, 0x99, 0x59, 0xd9, 0x39, 0xb9, 0x79, 0xf9,
|
|
|
1086 0x05, 0x85, 0x45, 0xc5, 0x25, 0xa5, 0x65, 0xe5, 0x15, 0x95, 0x55, 0xd5, 0x35, 0xb5, 0x75, 0xf5,
|
|
|
1087 0x0d, 0x8d, 0x4d, 0xcd, 0x2d, 0xad, 0x6d, 0xed, 0x1d, 0x9d, 0x5d, 0xdd, 0x3d, 0xbd, 0x7d, 0xfd,
|
|
|
1088 0x03, 0x83, 0x43, 0xc3, 0x23, 0xa3, 0x63, 0xe3, 0x13, 0x93, 0x53, 0xd3, 0x33, 0xb3, 0x73, 0xf3,
|
|
|
1089 0x0b, 0x8b, 0x4b, 0xcb, 0x2b, 0xab, 0x6b, 0xeb, 0x1b, 0x9b, 0x5b, 0xdb, 0x3b, 0xbb, 0x7b, 0xfb,
|
|
|
1090 0x07, 0x87, 0x47, 0xc7, 0x27, 0xa7, 0x67, 0xe7, 0x17, 0x97, 0x57, 0xd7, 0x37, 0xb7, 0x77, 0xf7,
|
|
|
1091 0x0f, 0x8f, 0x4f, 0xcf, 0x2f, 0xaf, 0x6f, 0xef, 0x1f, 0x9f, 0x5f, 0xdf, 0x3f, 0xbf, 0x7f, 0xff};
|
|
|
1092 template<class DataType, class DataSize> inline int lzExtract(DataType& datatype,const char*& src, char*& dest, const char* srcend, char* destend) {
|
|
|
1093 int count = 0;
|
|
|
1094 const char* lsrcend = srcend; char* ldestend = destend;
|
|
|
1095 const char* lsrc = src; char* ldest = dest;
|
|
|
1096
|
|
|
1097 if (lsrc+50 < lsrcend && ldest+1024 < ldestend) {
|
|
|
1098 /* まず、範囲チェックを緩くして高速なルーチンを使う */
|
|
|
1099 lsrcend -= 50;
|
|
|
1100 ldestend += 1024;
|
|
|
1101 while (ldest < ldestend && lsrc < lsrcend) {
|
|
|
1102 count += 8;
|
|
|
1103 int flag = int(*(unsigned char*)lsrc++);
|
|
|
1104 if (datatype.IsRev()) flag = bitrev_table[flag];
|
|
|
1105 int i; for (i=0; i<8; i++) {
|
|
|
1106 if (flag & 0x80) {
|
|
|
1107 datatype.Copy1Pixel(lsrc, ldest);
|
|
|
1108 } else {
|
|
|
1109 int data, size;
|
|
|
1110 datatype.ExtractData(lsrc, data, size);
|
|
|
1111 DataSize* p_dest = ((DataSize*)ldest) - data;
|
|
|
1112 int k; for (k=0; k<size; k++) {
|
|
|
1113 p_dest[data] = *p_dest;
|
|
|
1114 p_dest++;
|
|
|
1115 }
|
|
|
1116 ldest += size*sizeof(DataSize);
|
|
|
1117 }
|
|
|
1118 flag <<= 1;
|
|
|
1119 }
|
|
|
1120 }
|
|
|
1121 lsrcend += 50;
|
|
|
1122 ldestend += 1024;
|
|
|
1123 }
|
|
|
1124 /* 残りを変換 */
|
|
|
1125 while (ldest < ldestend && lsrc < lsrcend) {
|
|
|
1126 count += 8;
|
|
|
1127 int flag = int(*(unsigned char*)lsrc++);
|
|
|
1128 if (datatype.IsRev()) flag = bitrev_table[flag];
|
|
|
1129 int i; for (i=0; i<8 && ldest < ldestend && lsrc < lsrcend; i++) {
|
|
|
1130 if (flag & 0x80) {
|
|
|
1131 datatype.Copy1Pixel(lsrc, ldest);
|
|
|
1132 } else {
|
|
|
1133 int data, size;
|
|
|
1134 datatype.ExtractData(lsrc, data, size);
|
|
|
1135 DataSize* p_dest = ((DataSize*)ldest) - data;
|
|
|
1136 int k; for (k=0; k<size; k++) {
|
|
|
1137 p_dest[data] = *p_dest;
|
|
|
1138 p_dest++;
|
|
|
1139 }
|
|
|
1140 ldest += size*sizeof(DataSize);
|
|
|
1141 }
|
|
|
1142 flag <<= 1;
|
|
|
1143 }
|
|
|
1144 }
|
|
|
1145 dest=ldest; src=lsrc;
|
|
|
1146 return 0;
|
|
|
1147 }
|
|
|
1148 /* 引数を減らすためのwrapper */
|
|
|
1149 template<class DataType, class DataSize> inline int lzExtract(DataType datatype, DataSize datasize ,const char*& src, char*& dest, const char* srcend, char* destend) {
|
|
|
1150 return lzExtract<DataType, DataSize>(datatype,src,dest,srcend,destend);
|
|
|
1151 }
|
|
|
1152
|
|
|
1153 /* 普通の PDT */
|
|
|
1154 class Extract_DataType {
|
|
|
1155 public:
|
|
|
1156 static void ExtractData(const char*& lsrc, int& data, int& size) {
|
|
|
1157 data = read_little_endian_short(lsrc) & 0xffff;
|
|
|
1158 size = (data & 0x0f) + 1;
|
|
|
1159 data = (data>>4)+1;
|
|
|
1160 lsrc += 2;
|
|
|
1161 }
|
|
|
1162 static void Copy1Pixel(const char*& lsrc, char*& ldest) {
|
|
|
1163 #ifdef WORDS_BIGENDIAN
|
|
|
1164 ldest[3] = lsrc[0];
|
|
|
1165 ldest[2] = lsrc[1];
|
|
|
1166 ldest[1] = lsrc[2];
|
|
|
1167 ldest[0] = 0;
|
|
|
1168 #else
|
|
|
1169 *(int*)ldest = read_little_endian_int(lsrc); ldest[3]=0;
|
|
|
1170 #endif
|
|
|
1171 lsrc += 3; ldest += 4;
|
|
|
1172 }
|
|
|
1173 static int IsRev(void) { return 0; }
|
|
|
1174 };
|
|
|
1175
|
|
|
1176 /* PDT11 の第一段階変換 */
|
|
|
1177 class Extract_DataType_PDT11 {
|
|
|
1178 int* index_table;
|
|
|
1179 public:
|
|
|
1180 Extract_DataType_PDT11(int* it) { index_table = it; }
|
|
|
1181 void ExtractData(const char*& lsrc, int& data, int& size) {
|
|
|
1182 data = int(*(const unsigned char*)lsrc);
|
|
|
1183 size = (data>>4) + 2;
|
|
|
1184 data = index_table[data&0x0f];
|
|
|
1185 lsrc++;
|
|
|
1186 }
|
|
|
1187 static void Copy1Pixel(const char*& lsrc, char*& ldest) {
|
|
|
1188 *ldest = *lsrc;
|
|
|
1189 ldest++; lsrc++;
|
|
|
1190 }
|
|
|
1191 static int IsRev(void) { return 0; }
|
|
|
1192 };
|
|
|
1193 /* マスク用 */
|
|
|
1194 class Extract_DataType_Mask {
|
|
|
1195 public:
|
|
|
1196 void ExtractData(const char*& lsrc, int& data, int& size) {
|
|
|
1197 int d = read_little_endian_short(lsrc) & 0xffff;
|
|
|
1198 size = (d & 0xff) + 2;
|
|
|
1199 data = (d>>8)+1;
|
|
|
1200 lsrc += 2;
|
|
|
1201 }
|
|
|
1202 static void Copy1Pixel(const char*& lsrc, char*& ldest) {
|
|
|
1203 *ldest = *lsrc;
|
|
|
1204 ldest++; lsrc++;
|
|
|
1205 }
|
|
|
1206 static int IsRev(void) { return 0; }
|
|
|
1207 };
|
|
|
1208 /* 書庫用 */
|
|
|
1209 class Extract_DataType_ARC {
|
|
|
1210 public:
|
|
|
1211 void ExtractData(const char*& lsrc, int& data, int& size) {
|
|
|
1212 data = read_little_endian_short(lsrc) & 0xffff;
|
|
|
1213 size = (data&0x0f) + 2;
|
|
|
1214 data = (data>>4) + 1;
|
|
|
1215 lsrc+= 2;
|
|
|
1216 }
|
|
|
1217 static void Copy1Pixel(const char*& lsrc, char*& ldest) {
|
|
|
1218 *ldest = *lsrc;
|
|
|
1219 ldest++; lsrc++;
|
|
|
1220 }
|
|
|
1221 static int IsRev(void) { return 0; }
|
|
|
1222 };
|
|
|
1223 /* avg2000 のシナリオ用 */
|
|
|
1224 class Extract_DataType_SCN2k {
|
|
|
1225 public:
|
|
|
1226 void ExtractData(const char*& lsrc, int& data, int& size) {
|
|
|
1227 data = read_little_endian_short(lsrc) & 0xffff;
|
|
|
1228 size = (data&0x0f) + 2;
|
|
|
1229 data = (data>>4);
|
|
|
1230 lsrc+= 2;
|
|
|
1231 }
|
|
|
1232 static void Copy1Pixel(const char*& lsrc, char*& ldest) {
|
|
|
1233 *ldest = *lsrc;
|
|
|
1234 ldest++; lsrc++;
|
|
|
1235 }
|
|
|
1236 static int IsRev(void) { return 1; }
|
|
|
1237 };
|
|
|
1238 /* ReadLive の type0 */
|
|
|
1239 class Extract_DataType_G00Type0 {
|
|
|
1240 public:
|
|
|
1241 static void ExtractData(const char*& lsrc, int& data, int& size) {
|
|
|
1242 data = read_little_endian_short(lsrc) & 0xffff;
|
|
|
1243 size = ((data & 0x0f)+ 1) * 3;
|
|
|
1244 data = (data>>4) * 3;
|
|
|
1245 lsrc += 2;
|
|
|
1246 }
|
|
|
1247 static void Copy1Pixel(const char*& lsrc, char*& ldest) {
|
|
|
1248 #ifdef WORDS_BIGENDIAN
|
|
|
1249 ldest[0] = lsrc[0];
|
|
|
1250 ldest[1] = lsrc[1];
|
|
|
1251 ldest[2] = lsrc[2];
|
|
|
1252 #else /* LITTLE ENDIAN / intel architecture */
|
|
|
1253 *(int*)ldest = *(int*)lsrc;
|
|
|
1254 #endif
|
|
|
1255 lsrc += 3; ldest += 3;
|
|
|
1256 }
|
|
|
1257 static int IsRev(void) { return 1; }
|
|
|
1258 };
|
|
|
1259
|
|
|
1260
|
|
|
1261 bool PDTCONV::Read(char* image) {
|
|
|
1262 if (data == 0) return false;
|
|
|
1263
|
|
|
1264 if (strncmp(data, "PDT10", 5) == 0) {
|
|
|
1265 if (! Read_PDT10(image)) return false;
|
|
|
1266 } else if (strncmp(data, "PDT11", 5) == 0) {
|
|
|
1267 if (! Read_PDT11(image)) return false;
|
|
|
1268 }
|
|
|
1269 if (! is_mask) return true;
|
|
|
1270 // マスク読み込み
|
|
|
1271 int mask_pt = read_little_endian_int(data + 0x1c);
|
|
|
1272 char* buf = new char[width*height+1024];
|
|
|
1273 const char* src = data + mask_pt;
|
|
|
1274 const char* srcend = data + datalen;
|
|
|
1275 char* dest = buf;
|
|
|
1276 char* destend = buf + width*height;
|
|
|
1277 while(lzExtract(Extract_DataType_Mask(), char(), src, dest, srcend, destend)) ;
|
|
|
1278 int i; int len = width*height;
|
|
|
1279 src = buf; dest = image;
|
|
|
1280 for (i=0; i<len; i++) {
|
|
|
1281 *(int*)dest |= int(*(unsigned char*)src) << 24;
|
|
|
1282 src++;
|
|
|
1283 dest += 4;
|
|
|
1284 }
|
|
|
1285 delete[] buf;
|
|
|
1286 return true;
|
|
|
1287 }
|
|
|
1288
|
|
|
1289
|
|
|
1290 bool PDTCONV::Read_PDT10(char* image) {
|
|
|
1291 int mask_pt = read_little_endian_int(data + 0x1c);
|
|
|
1292
|
|
|
1293 const char* src = data + 0x20;
|
|
|
1294 const char* srcend;
|
|
|
1295 if (mask_pt == 0) srcend = data + datalen;
|
|
|
1296 else srcend = data + mask_pt;
|
|
|
1297
|
|
|
1298 char* dest = image;
|
|
|
1299 char* destend;
|
|
|
1300
|
|
|
1301 destend = image + width*height*4;
|
|
|
1302 while(lzExtract(Extract_DataType(), int(), src, dest, srcend, destend)) ;
|
|
|
1303 return true;
|
|
|
1304 }
|
|
|
1305 bool PDTCONV::Read_PDT11(char* image) {
|
|
|
1306 int index_table[16];
|
|
|
1307 int color_table[256];
|
|
|
1308 int i;
|
|
|
1309 for (i=0; i<16; i++)
|
|
|
1310 index_table[i] = read_little_endian_int(data + 0x420 + i*4);
|
|
|
1311
|
|
|
1312 int mask_pt = read_little_endian_int(data + 0x1c);
|
|
|
1313
|
|
|
1314 const char* src = data + 0x460;
|
|
|
1315 const char* srcend;
|
|
|
1316 if (mask_pt == 0) srcend = data + datalen;
|
|
|
1317 else srcend = data + mask_pt;
|
|
|
1318
|
|
|
1319 char* dest = image;
|
|
|
1320 char* destend = image + width*height;
|
|
|
1321
|
|
|
1322 while(lzExtract(Extract_DataType_PDT11(index_table), char(), src, dest, srcend, destend)) ;
|
|
|
1323
|
|
|
1324 const char* cur = data + 0x20;
|
|
|
1325 for (i=0; i<256; i++) {
|
|
|
1326 color_table[i] = read_little_endian_int(cur);
|
|
|
1327 cur += 4;
|
|
|
1328 }
|
|
|
1329 src = image + width*height;
|
|
|
1330 int* desti = (int*)(image + width*height*4);
|
|
|
1331 while(desti != (int*)image)
|
|
|
1332 *--desti = color_table[*(unsigned char*)--src];
|
|
|
1333 return true;
|
|
|
1334 }
|
|
|
1335
|
|
|
1336 /* dest は dest_end よりも 256 byte 以上先まで
|
|
|
1337 ** 書き込み可能であること。
|
|
|
1338 */
|
|
|
1339 void ARCINFO::Extract(char*& dest_start, char*& src_start, char* dest_end, char* src_end) {
|
|
|
1340 const char* src = src_start;
|
|
|
1341 while (lzExtract(Extract_DataType_ARC(), char(), src, dest_start, src_end, dest_end)) ;
|
|
|
1342 src_start = (char*)src;
|
|
|
1343 return;
|
|
|
1344 }
|
|
|
1345 void ARCINFO::Extract2k(char*& dest_start, char*& src_start, char* dest_end, char* src_end) {
|
|
|
1346 const char* src = src_start;
|
|
|
1347 while (lzExtract(Extract_DataType_SCN2k(), char(), src, dest_start, src_end, dest_end)) ;
|
|
|
1348 src_start = (char*)src;
|
|
|
1349 return;
|
|
|
1350 }
|
|
|
1351
|
|
|
1352 bool ARCINFO_AVG32::ExecExtract(void) {
|
|
|
1353 // ヘッダのチェック
|
|
|
1354 if (strncmp(data, "PACK", 4) != 0) return false;
|
|
|
1355 if (read_little_endian_int(data+8) != info.filesize) return false;
|
|
|
1356 if (read_little_endian_int(data+12) != info.arcsize) return false;
|
|
|
1357
|
|
|
1358 // ファイルを展開する
|
|
|
1359 char* ret_data = new char[info.filesize+1024];
|
|
|
1360
|
|
|
1361 const char* s = data + 0x10;
|
|
|
1362 const char* send = data + info.arcsize;
|
|
|
1363 char* d = ret_data;
|
|
|
1364 char* dend = ret_data + info.filesize;
|
|
|
1365 while(lzExtract(Extract_DataType_ARC(), char(), s, d, send, dend)) ;
|
|
|
1366 if (! use_mmap) delete[] data;
|
|
|
1367 data = ret_data;
|
|
|
1368 return true;
|
|
|
1369 }
|
|
|
1370
|
|
|
1371 char ARCINFO2k::decode_seed[256] ={
|
|
|
1372 0x8b ,0xe5 ,0x5d ,0xc3 ,0xa1 ,0xe0 ,0x30 ,0x44 ,0x00 ,0x85 ,0xc0 ,0x74 ,0x09 ,0x5f ,0x5e ,0x33
|
|
|
1373 ,0xc0 ,0x5b ,0x8b ,0xe5 ,0x5d ,0xc3 ,0x8b ,0x45 ,0x0c ,0x85 ,0xc0 ,0x75 ,0x14 ,0x8b ,0x55 ,0xec
|
|
|
1374 ,0x83 ,0xc2 ,0x20 ,0x52 ,0x6a ,0x00 ,0xe8 ,0xf5 ,0x28 ,0x01 ,0x00 ,0x83 ,0xc4 ,0x08 ,0x89 ,0x45
|
|
|
1375 ,0x0c ,0x8b ,0x45 ,0xe4 ,0x6a ,0x00 ,0x6a ,0x00 ,0x50 ,0x53 ,0xff ,0x15 ,0x34 ,0xb1 ,0x43 ,0x00
|
|
|
1376 ,0x8b ,0x45 ,0x10 ,0x85 ,0xc0 ,0x74 ,0x05 ,0x8b ,0x4d ,0xec ,0x89 ,0x08 ,0x8a ,0x45 ,0xf0 ,0x84
|
|
|
1377 ,0xc0 ,0x75 ,0x78 ,0xa1 ,0xe0 ,0x30 ,0x44 ,0x00 ,0x8b ,0x7d ,0xe8 ,0x8b ,0x75 ,0x0c ,0x85 ,0xc0
|
|
|
1378 ,0x75 ,0x44 ,0x8b ,0x1d ,0xd0 ,0xb0 ,0x43 ,0x00 ,0x85 ,0xff ,0x76 ,0x37 ,0x81 ,0xff ,0x00 ,0x00
|
|
|
1379 ,0x04 ,0x00 ,0x6a ,0x00 ,0x76 ,0x43 ,0x8b ,0x45 ,0xf8 ,0x8d ,0x55 ,0xfc ,0x52 ,0x68 ,0x00 ,0x00
|
|
|
1380 ,0x04 ,0x00 ,0x56 ,0x50 ,0xff ,0x15 ,0x2c ,0xb1 ,0x43 ,0x00 ,0x6a ,0x05 ,0xff ,0xd3 ,0xa1 ,0xe0
|
|
|
1381 ,0x30 ,0x44 ,0x00 ,0x81 ,0xef ,0x00 ,0x00 ,0x04 ,0x00 ,0x81 ,0xc6 ,0x00 ,0x00 ,0x04 ,0x00 ,0x85
|
|
|
1382 ,0xc0 ,0x74 ,0xc5 ,0x8b ,0x5d ,0xf8 ,0x53 ,0xe8 ,0xf4 ,0xfb ,0xff ,0xff ,0x8b ,0x45 ,0x0c ,0x83
|
|
|
1383 ,0xc4 ,0x04 ,0x5f ,0x5e ,0x5b ,0x8b ,0xe5 ,0x5d ,0xc3 ,0x8b ,0x55 ,0xf8 ,0x8d ,0x4d ,0xfc ,0x51
|
|
|
1384 ,0x57 ,0x56 ,0x52 ,0xff ,0x15 ,0x2c ,0xb1 ,0x43 ,0x00 ,0xeb ,0xd8 ,0x8b ,0x45 ,0xe8 ,0x83 ,0xc0
|
|
|
1385 ,0x20 ,0x50 ,0x6a ,0x00 ,0xe8 ,0x47 ,0x28 ,0x01 ,0x00 ,0x8b ,0x7d ,0xe8 ,0x89 ,0x45 ,0xf4 ,0x8b
|
|
|
1386 ,0xf0 ,0xa1 ,0xe0 ,0x30 ,0x44 ,0x00 ,0x83 ,0xc4 ,0x08 ,0x85 ,0xc0 ,0x75 ,0x56 ,0x8b ,0x1d ,0xd0
|
|
|
1387 ,0xb0 ,0x43 ,0x00 ,0x85 ,0xff ,0x76 ,0x49 ,0x81 ,0xff ,0x00 ,0x00 ,0x04 ,0x00 ,0x6a ,0x00 ,0x76};
|
|
|
1388 char ARCINFO2k::decode_seed2[16] = {
|
|
|
1389 0xa8, 0x28, 0xfd, 0x66,
|
|
|
1390 0xa0, 0x23, 0x77, 0x69,
|
|
|
1391 0xf9, 0x45, 0xf8, 0x2c,
|
|
|
1392 0x7c, 0x00, 0xad, 0xf4
|
|
|
1393 };
|
|
|
1394
|
|
|
1395 bool ARCINFO2k::ExecExtract(void) {
|
|
|
1396 int i;
|
|
|
1397 char* ret_data = new char[info.filesize + 1024];
|
|
|
1398 char* decoded_data = new char[info.arcsize + 1024];
|
|
|
1399
|
|
|
1400 /* header のコピー */
|
|
|
1401 memcpy(ret_data, data, info.private_data);
|
|
|
1402
|
|
|
1403 /* まず、xor の暗号化を解く */
|
|
|
1404 const char* s; const char* send;
|
|
|
1405 char* d; char* dend;
|
|
|
1406
|
|
|
1407 s = data + info.private_data;
|
|
|
1408 send = data + info.arcsize;
|
|
|
1409 d = decoded_data + info.private_data;
|
|
|
1410 dend = decoded_data + info.arcsize;
|
|
|
1411 i = 0;
|
|
|
1412 while(s != send)
|
|
|
1413 *d++ = *s++ ^ decode_seed[(i++)&0xff];
|
|
|
1414
|
|
|
1415 if (info.filesize == info.arcsize) {
|
|
|
1416 memcpy(ret_data+info.private_data, decoded_data + info.private_data + 8, info.arcsize - info.private_data - 8);
|
|
|
1417 } else {
|
|
|
1418 /* 圧縮されているなら、それを展開 */
|
|
|
1419 s = (const char*)(decoded_data + info.private_data + 8);
|
|
|
1420 send = (const char*)(decoded_data + info.arcsize);
|
|
|
1421 d = ret_data + info.private_data;
|
|
|
1422 dend = ret_data + info.filesize;
|
|
|
1423 while(lzExtract(Extract_DataType_SCN2k(), char(), s, d, send, dend)) ;
|
|
|
1424 }
|
|
|
1425 if (read_little_endian_int(data+4) == 0x1adb2) { // Little Busters!
|
|
|
1426 int header_size = info.private_data;
|
|
|
1427 for (i=0x100; i<=0x200 && header_size+i < info.filesize; i++) {
|
|
|
1428 ret_data[header_size+i] ^= decode_seed2[i&0x0f];
|
|
|
1429 }
|
|
|
1430 }
|
|
|
1431 delete[] decoded_data;
|
|
|
1432 if (! use_mmap) delete[] data;
|
|
|
1433 data = ret_data;
|
|
|
1434 return true;
|
|
|
1435 }
|
|
|
1436
|
|
|
1437 bool G00CONV::Read_Type0(char* image) {
|
|
|
1438 int uncompress_size = read_little_endian_int(data+9);
|
|
|
1439 char* uncompress_data = new char[uncompress_size+1024];
|
|
|
1440
|
|
|
1441 // まず展開
|
|
|
1442 const char* src = data + 13;
|
|
|
1443 const char* srcend = data + datalen;
|
|
|
1444 char* dest = uncompress_data;
|
|
|
1445 char* dstend = uncompress_data + uncompress_size;
|
|
|
1446 while(lzExtract(Extract_DataType_G00Type0(), char(), src, dest, srcend, dstend));
|
|
|
1447 // image にコピー
|
|
|
1448 CopyRGB(image, uncompress_data);
|
|
|
1449 delete[] uncompress_data;
|
|
|
1450 return true;
|
|
|
1451 }
|
|
|
1452 bool G00CONV::Read_Type1(char* image) {
|
|
|
1453 int i;
|
|
|
1454 int uncompress_size = read_little_endian_int(data+9) + 1;
|
|
|
1455 char* uncompress_data = new char[uncompress_size + 1024];
|
|
|
1456
|
|
|
1457 // まず、展開
|
|
|
1458 const char* src = data + 13;
|
|
|
1459 const char* srcend = data + datalen;
|
|
|
1460 char* dest = uncompress_data;
|
|
|
1461 char* destend = uncompress_data + uncompress_size;
|
|
|
1462
|
|
|
1463 while(lzExtract(Extract_DataType_SCN2k(), char(), src, dest, srcend, destend));
|
|
|
1464
|
|
|
1465 int colortable[256];
|
|
|
1466 memset(colortable, 0, sizeof(int)*256);
|
|
|
1467 int colortable_len = read_little_endian_short(uncompress_data);
|
|
|
1468 if (colortable_len > 256) colortable_len = 256;
|
|
|
1469 if (colortable_len < 0) colortable_len = 0;
|
|
|
1470 for (i=0; i<colortable_len; i++) {
|
|
|
1471 colortable[i] = read_little_endian_int(uncompress_data+2+i*4);
|
|
|
1472 }
|
|
|
1473 src = uncompress_data + 2 + read_little_endian_short(uncompress_data)*4;
|
|
|
1474 srcend = uncompress_data + uncompress_size;
|
|
|
1475 dest = image; destend = image + width*height*4;
|
|
|
1476 while(dest < destend && src < srcend) {
|
|
|
1477 *(int*)dest = colortable[*(unsigned char*)src];
|
|
|
1478 dest += 4; src ++;
|
|
|
1479 }
|
|
|
1480 delete[] uncompress_data;
|
|
|
1481 return true;
|
|
|
1482 }
|
|
|
1483
|
|
|
1484 bool G00CONV::Read_Type2(char* image) {
|
|
|
1485 memset(image, 0, width*height*4);
|
|
|
1486 /* 分割領域を得る */
|
|
|
1487 int region_deal = read_little_endian_int(data+5);
|
|
|
1488 REGION* region_table = new REGION[region_deal];
|
|
|
1489
|
|
|
1490 const char* head = data + 9;
|
|
|
1491 int i; for (i=0; i<region_deal; i++) {
|
|
|
1492 region_table[i].x1 = read_little_endian_int(head+0);
|
|
|
1493 region_table[i].y1 = read_little_endian_int(head+4);
|
|
|
1494 region_table[i].x2 = read_little_endian_int(head+8);
|
|
|
1495 region_table[i].y2 = read_little_endian_int(head+12);
|
|
|
1496 region_table[i].Fix(width, height);
|
|
|
1497 head += 24;
|
|
|
1498 }
|
|
|
1499
|
|
|
1500 // 展開
|
|
|
1501 int uncompress_size = read_little_endian_int(head+4);
|
|
|
1502 char* uncompress_data = new char[uncompress_size + 1024];
|
|
|
1503
|
|
|
1504 const char* src = head + 8;
|
|
|
1505 const char* srcend = data + datalen;
|
|
|
1506 char* dest = uncompress_data;
|
|
|
1507 char* destend = uncompress_data + uncompress_size;
|
|
|
1508 while(lzExtract(Extract_DataType_SCN2k(), char(), src, dest, srcend, destend));
|
|
|
1509
|
|
|
1510 /* region_deal2 == region_deal のはず……*/
|
|
|
1511 int region_deal2 = read_little_endian_int(uncompress_data);
|
|
|
1512 if (region_deal > region_deal2) region_deal = region_deal2;
|
|
|
1513
|
|
|
1514 for (i=0; i < region_deal; i++) {
|
|
|
1515 int offset = read_little_endian_int(uncompress_data + i*8 + 4);
|
|
|
1516 int length = read_little_endian_int(uncompress_data + i*8 + 8);
|
|
|
1517 src = (const char*)(uncompress_data + offset + 0x74);
|
|
|
1518 srcend = (const char*)(uncompress_data + offset + length);
|
|
|
1519 while(src < srcend) {
|
|
|
1520 int x, y, w, h;
|
|
|
1521 /* コピーする領域を得る */
|
|
|
1522 x = read_little_endian_short(src);
|
|
|
1523 y = read_little_endian_short(src+2);
|
|
|
1524 w = read_little_endian_short(src+6);
|
|
|
1525 h = read_little_endian_short(src+8);
|
|
|
1526 src += 0x5c;
|
|
|
1527
|
|
|
1528 x += region_table[i].x1;
|
|
|
1529 y += region_table[i].y1;
|
|
|
1530
|
|
|
1531 Copy_32bpp(image, x, y, src, w*4, h);
|
|
|
1532
|
|
|
1533 src += w*h*4;
|
|
|
1534 }
|
|
|
1535 }
|
|
|
1536 delete[] uncompress_data;
|
|
7
|
1537 delete[] region_table;
|
|
0
|
1538 return true;
|
|
|
1539 }
|
|
|
1540
|
|
|
1541 void G00CONV::Copy_32bpp(char* image, int x, int y, const char* src, int bpl, int h) {
|
|
|
1542 int i;
|
|
|
1543 int* dest = (int*)(image + x*4 + y*4*width);
|
|
|
1544 int w = bpl / 4;
|
|
|
1545 for (i=0; i<h; i++) {
|
|
|
1546 const char* s = src;
|
|
|
1547 int* d = dest;
|
|
|
1548 int j; for (j=0; j<w; j++) {
|
|
|
1549 *d++ = read_little_endian_int(s);
|
|
|
1550 s += 4;
|
|
|
1551 }
|
|
|
1552 src += bpl; dest += width;
|
|
|
1553 }
|
|
|
1554 }
|
|
|
1555
|
|
|
1556 void GRPCONV::CopyRGBA_rev(char* image, const char* buf) {
|
|
|
1557 int mask = is_mask ? 0 : 0xff000000;
|
|
|
1558 /* 色変換を行う */
|
|
|
1559 int len = width * height;
|
|
|
1560 int i;
|
|
|
1561 unsigned char* s = (unsigned char*)buf;
|
|
|
1562 int* d = (int*)image;
|
|
|
1563 for(i=0; i<len; i++) {
|
|
|
1564 *d = (int(s[2])) | (int(s[1])<<8) | (int(s[0])<<16) | (int(s[3])<<24) | mask;
|
|
|
1565 d++; s += 4;
|
|
|
1566 }
|
|
|
1567 return;
|
|
|
1568 }
|
|
|
1569
|
|
|
1570 void GRPCONV::CopyRGBA(char* image, const char* buf) {
|
|
|
1571 if (!is_mask) {
|
|
|
1572 CopyRGB(image, buf);
|
|
|
1573 return;
|
|
|
1574 }
|
|
|
1575 /* 色変換を行う */
|
|
|
1576 int len = width * height;
|
|
|
1577 int i;
|
|
|
1578 int* outbuf = (int*)image;
|
|
|
1579 for(i=0; i<len; i++) {
|
|
|
1580 *outbuf++ = read_little_endian_int(buf);
|
|
|
1581 buf += 4;
|
|
|
1582 }
|
|
|
1583 return;
|
|
|
1584 }
|
|
|
1585 void GRPCONV::CopyRGB(char* image, const char* buf) {
|
|
|
1586 /* 色変換を行う */
|
|
|
1587 int len = width * height;
|
|
|
1588 int i;
|
|
|
1589 unsigned char* s = (unsigned char*)buf;
|
|
|
1590 int* d = (int*)image;
|
|
|
1591 for(i=0; i<len; i++) {
|
|
|
1592 *d = (int(s[0])) | (int(s[1])<<8) | (int(s[2])<<16) | 0xff000000;
|
|
|
1593 d++; s+=3;
|
|
|
1594 }
|
|
|
1595 return;
|
|
|
1596 }
|
|
|
1597
|
|
|
1598 #if HAVE_LIBPNG
|
|
|
1599 PNGCONV::PNGCONV(const char* _inbuf, int _inlen, const char* _filename) {
|
|
|
1600 int w,h,type;
|
|
|
1601 png_structp png_ptr = 0;
|
|
|
1602 png_infop info_ptr = 0;
|
|
|
1603 png_infop end_info = 0;
|
|
|
1604
|
|
|
1605 png_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING, 0, 0, 0);
|
|
|
1606 if (!png_ptr) return;
|
|
|
1607
|
|
|
1608 info_ptr = png_create_info_struct(png_ptr);
|
|
|
1609 if (!info_ptr) goto err;
|
|
|
1610
|
|
|
1611 end_info = png_create_info_struct(png_ptr);
|
|
|
1612 if (!end_info) goto err;
|
|
|
1613
|
|
|
1614 if (setjmp(png_jmpbuf(png_ptr))) {
|
|
|
1615 /* error occured !! */
|
|
|
1616 goto err;
|
|
|
1617 }
|
|
|
1618
|
|
|
1619 /* initialize I/O */
|
|
|
1620 png_data = _inbuf;
|
|
|
1621 png_set_read_fn(png_ptr, (png_voidp)this, &png_read);
|
|
|
1622
|
|
|
1623 png_read_info(png_ptr, info_ptr);
|
|
|
1624
|
|
|
1625 w = png_get_image_width(png_ptr, info_ptr);
|
|
|
1626 h = png_get_image_height(png_ptr, info_ptr);
|
|
|
1627 type = png_get_color_type(png_ptr, info_ptr);
|
|
|
1628
|
|
|
1629 if (type == PNG_COLOR_TYPE_GRAY || type == PNG_COLOR_TYPE_GRAY_ALPHA) goto err; // not supported
|
|
|
1630
|
|
|
1631 Init(filename, _inbuf, _inlen, w, h, type == PNG_COLOR_TYPE_RGB_ALPHA ? true : false);
|
|
|
1632
|
|
|
1633 err:
|
|
|
1634 if (png_ptr) {
|
|
|
1635 if (end_info)
|
|
|
1636 png_destroy_read_struct(&png_ptr, &info_ptr,&end_info);
|
|
|
1637 else if (info_ptr)
|
|
|
1638 png_destroy_read_struct(&png_ptr, &info_ptr,(png_infopp)0);
|
|
|
1639 else
|
|
|
1640 png_destroy_read_struct(&png_ptr, (png_infopp) 0,(png_infopp)0);
|
|
|
1641 }
|
|
|
1642 return;
|
|
|
1643 }
|
|
|
1644
|
|
|
1645 bool PNGCONV::Read(char* image) {
|
|
|
1646 if (data == 0) return false;
|
|
|
1647 bool retcode = false;
|
|
|
1648 int bpp = is_mask ? 4 : 3;
|
|
|
1649 int i;
|
|
|
1650 char* buf;
|
|
|
1651 png_bytepp row_pointers = 0;
|
|
|
1652
|
|
|
1653 png_structp png_ptr = 0;
|
|
|
1654 png_infop info_ptr = 0;
|
|
|
1655 png_infop end_info = 0;
|
|
|
1656
|
|
|
1657 png_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING, 0, 0, 0);
|
|
|
1658 if (!png_ptr) goto err;
|
|
|
1659 info_ptr = png_create_info_struct(png_ptr);
|
|
|
1660 if (!info_ptr) goto err;
|
|
|
1661 end_info = png_create_info_struct(png_ptr);
|
|
|
1662 if (!end_info) goto err;
|
|
|
1663
|
|
|
1664 if (setjmp(png_jmpbuf(png_ptr))) {
|
|
|
1665 /* error occured !! */
|
|
|
1666 goto err;
|
|
|
1667 }
|
|
|
1668
|
|
|
1669 buf= new char[width*height*4];
|
|
|
1670 /* initialize I/O */
|
|
|
1671 png_data = data;
|
|
|
1672 png_set_read_fn(png_ptr, (png_voidp)this, &png_read);
|
|
|
1673
|
|
|
1674 row_pointers = (png_bytepp)png_malloc(png_ptr, height*sizeof(png_bytep));
|
|
|
1675 for (i=0; i<height; i++) row_pointers[i] = (png_bytep)(buf + width*bpp*i);
|
|
|
1676 png_set_rows(png_ptr, info_ptr, row_pointers);
|
|
|
1677
|
|
|
1678 png_read_png(png_ptr, info_ptr,
|
|
|
1679 PNG_TRANSFORM_STRIP_16 | PNG_TRANSFORM_EXPAND | PNG_TRANSFORM_PACKING | PNG_TRANSFORM_BGR,0);
|
|
|
1680
|
|
|
1681 if (buf != image) {
|
|
|
1682 CopyRGBA(image, buf);
|
|
|
1683 delete[] buf;
|
|
|
1684 }
|
|
|
1685 png_free(png_ptr, (png_voidp)row_pointers);
|
|
|
1686
|
|
|
1687 retcode = true;
|
|
|
1688 err:
|
|
|
1689 if (png_ptr) {
|
|
|
1690 if (end_info)
|
|
|
1691 png_destroy_read_struct(&png_ptr, &info_ptr,&end_info);
|
|
|
1692 else if (info_ptr)
|
|
|
1693 png_destroy_read_struct(&png_ptr, &info_ptr,(png_infopp)0);
|
|
|
1694 else
|
|
|
1695 png_destroy_read_struct(&png_ptr, (png_infopp) 0,(png_infopp)0);
|
|
|
1696 }
|
|
|
1697 return retcode;
|
|
|
1698 }
|
|
|
1699
|
|
|
1700 void PNGCONV::png_read(png_structp png_ptr, png_bytep d, png_size_t sz) {
|
|
|
1701 PNGCONV* orig = (PNGCONV*)png_get_io_ptr(png_ptr);
|
|
|
1702 memcpy(d, orig->png_data, sz);
|
|
|
1703 orig->png_data += sz;
|
|
|
1704 return;
|
|
|
1705 }
|
|
|
1706 #endif /* HAVE_LIBPNG */
|
|
|
1707
|
|
|
1708 #if HAVE_LIBJPEG
|
|
|
1709 JPEGCONV::JPEGCONV(const char* _inbuf, int _inlen, const char* _filename) {
|
|
|
1710 int w,h,type;
|
|
|
1711 JSAMPARRAY rows, rows_orig; int i;
|
|
|
1712 char* buf = 0;
|
|
|
1713
|
|
|
1714 struct jpeg_decompress_struct cinfo;
|
|
|
1715 struct jpeg_error_mgr jerr;
|
|
|
1716 cinfo.err = jpeg_std_error(&jerr);
|
|
|
1717 jpeg_create_decompress(&cinfo);
|
|
|
1718 cinfo.src = new jpeg_source_mgr;
|
|
|
1719 SetupSrc(&cinfo, _inbuf, _inlen);
|
|
|
1720
|
|
|
1721 if (jpeg_read_header(&cinfo, TRUE) == JPEG_HEADER_OK) {
|
|
|
1722 Init(filename, _inbuf, _inlen, cinfo.image_width, cinfo.image_height, false);
|
|
|
1723 }
|
|
|
1724 delete cinfo.src;
|
|
|
1725 cinfo.src = 0;
|
|
|
1726 jpeg_destroy_decompress(&cinfo);
|
|
|
1727 return;
|
|
|
1728 }
|
|
|
1729
|
|
|
1730 bool JPEGCONV::Read(char* image) {
|
|
|
1731 if (data == 0) return false;
|
|
|
1732 bool retcode = false;
|
|
|
1733 JSAMPARRAY rows, rows_orig; int i;
|
|
|
1734 char* buf = 0;
|
|
|
1735
|
|
|
1736 struct jpeg_decompress_struct cinfo;
|
|
|
1737 struct jpeg_error_mgr jerr;
|
|
|
1738 cinfo.err = jpeg_std_error(&jerr);
|
|
|
1739 jpeg_create_decompress(&cinfo);
|
|
|
1740 cinfo.src = new jpeg_source_mgr;
|
|
|
1741 SetupSrc(&cinfo, data, datalen);
|
|
|
1742
|
|
|
1743 if (jpeg_read_header(&cinfo, TRUE) != JPEG_HEADER_OK) goto err;
|
|
|
1744
|
|
|
1745 cinfo.out_color_space = JCS_RGB;
|
|
|
1746
|
|
|
1747 jpeg_start_decompress(&cinfo);
|
|
|
1748
|
|
|
1749 rows = new JSAMPROW[height];
|
|
|
1750 rows_orig = rows;
|
|
|
1751 buf = new char[width*height*3];
|
|
|
1752 for (i=0; i<height; i++) rows[i] = (JSAMPROW)(buf+width*3*i);
|
|
|
1753
|
|
|
1754 for (i=0; i<height; ) {
|
|
|
1755 int cnt = jpeg_read_scanlines(&cinfo, rows, height-i);
|
|
|
1756 rows += cnt;
|
|
|
1757 i += cnt;
|
|
|
1758 }
|
|
|
1759 delete[] rows_orig;
|
|
|
1760 CopyRGBA_rev(image, buf);
|
|
|
1761 delete[] buf;
|
|
|
1762
|
|
|
1763 jpeg_finish_decompress(&cinfo);
|
|
|
1764 retcode = true;
|
|
|
1765 err:
|
|
|
1766 delete cinfo.src;
|
|
|
1767 cinfo.src = 0;
|
|
|
1768 jpeg_destroy_decompress(&cinfo);
|
|
|
1769 return retcode;
|
|
|
1770 }
|
|
|
1771
|
|
|
1772 void JPEGCONV::init_source(j_decompress_ptr cinfo) {
|
|
|
1773 }
|
|
|
1774 boolean JPEGCONV::fill_input_buffer(j_decompress_ptr cinfo) {
|
|
|
1775 static char dummy[1024];
|
|
|
1776 memset(dummy, 0, 1024);
|
|
|
1777 cinfo->src->next_input_byte = (const JOCTET*)dummy;
|
|
|
1778 cinfo->src->bytes_in_buffer = 1024;
|
|
|
1779 fprintf(stderr,"JPEGCONV::fill_input_buffer: warning corrupted jpeg stream\n");
|
|
|
1780 return TRUE;
|
|
|
1781 }
|
|
|
1782 void JPEGCONV::skip_input_data(j_decompress_ptr cinfo, long num_bytes) {
|
|
|
1783 if (cinfo->src->bytes_in_buffer > num_bytes) {
|
|
|
1784 cinfo->src->next_input_byte += num_bytes;
|
|
|
1785 cinfo->src->bytes_in_buffer -= num_bytes;
|
|
|
1786 }
|
|
|
1787 }
|
|
|
1788 boolean JPEGCONV::resync_to_restart(j_decompress_ptr cinfo, int desired) {
|
|
|
1789 return jpeg_resync_to_restart(cinfo, desired);
|
|
|
1790 }
|
|
|
1791 void JPEGCONV::term_source(j_decompress_ptr cinf) {
|
|
|
1792 }
|
|
|
1793
|
|
|
1794 void JPEGCONV::SetupSrc(struct jpeg_decompress_struct* cinfo, const char* data, int size) {
|
|
|
1795 cinfo->src->next_input_byte = (const JOCTET*) data;
|
|
|
1796 cinfo->src->bytes_in_buffer = size;
|
|
|
1797 cinfo->src->init_source = init_source;
|
|
|
1798 cinfo->src->fill_input_buffer = fill_input_buffer;
|
|
|
1799 cinfo->src->skip_input_data = skip_input_data;
|
|
|
1800 cinfo->src->resync_to_restart = resync_to_restart;
|
|
|
1801 cinfo->src->term_source = term_source;
|
|
|
1802 }
|
|
|
1803 #endif /* HAVE_LIBJPEG */
|
|
|
1804 BMPCONV::BMPCONV(const char* _inbuf, int _inlen, const char* _filename) {
|
|
|
1805 /* データから情報読み込み */
|
|
|
1806 int w = read_little_endian_int(_inbuf + 0x12);
|
|
|
1807 int h = read_little_endian_int(_inbuf + 0x16);
|
|
|
1808 if (h < 0) h = -h;
|
|
|
1809 int bpp = read_little_endian_short(_inbuf + 0x1c);
|
|
|
1810 int comp = read_little_endian_int(_inbuf + 0x1e);
|
|
|
1811 Init(filename, _inbuf, _inlen, w, h, bpp==32 ? true : false);
|
|
|
1812 return;
|
|
|
1813 }
|
|
|
1814
|
|
|
1815 bool BMPCONV::Read(char* image) {
|
|
|
1816 if (data == 0) return false;
|
|
|
1817
|
|
|
1818 /* マスクのチェック */
|
|
|
1819 int bpp = read_little_endian_short(data+0x1c);
|
|
|
1820 int h = read_little_endian_int(data + 0x16);
|
|
|
1821 int dsz = read_little_endian_int(data + 0x22);
|
|
|
1822 bpp /= 8;
|
|
|
1823
|
|
|
1824 int bpl = dsz / height;
|
|
|
1825 if (bpl == 0) bpl = bpp*width;
|
|
|
1826 bpl = bpp * width;
|
|
|
1827 bpl = (bpl+3) & (~3);
|
|
|
1828
|
|
|
1829
|
|
|
1830 int i;
|
|
|
1831 char* buf = new char[width*height*bpp+1024];
|
|
|
1832 const char* src = data + 0x36;
|
|
|
1833 char* dest = buf;
|
|
|
1834 if (h < 0) {
|
|
|
1835 for (i=0; i<height; i++) {
|
|
|
1836 memcpy(dest+i*width*bpp, src+i*bpl, width*bpp);
|
|
|
1837 }
|
|
|
1838 } else {
|
|
|
1839 for (i=0; i<height; i++) {
|
|
|
1840 memcpy(dest+i*width*bpp, src+(height-i-1)*bpl, width*bpp);
|
|
|
1841 }
|
|
|
1842 }
|
|
|
1843 if (bpp == 3) CopyRGB(image, buf);
|
|
|
1844 else /* bpp == 4 */ CopyRGBA(image, buf);
|
|
|
1845 delete[] buf;
|
|
|
1846 return true;
|
|
|
1847 }
|
|
|
1848
|
