|
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 *
|
|
27
|
24 * You should have received a copy of the GNU General Public License along
|
|
|
25 * with this program; if not, write to the Free Software Foundation, Inc.,
|
|
|
26 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
|
|
0
|
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);
|
|
9
|
594 delete[] dat_path;
|
|
0
|
595 dat_dir->Init();
|
|
|
596 }
|
|
|
597 searcher[ALL] = dat_dir;
|
|
|
598 searcher[ROOT] = root_dir;
|
|
|
599 return 0;
|
|
|
600 }
|
|
|
601
|
|
30
|
602 void FILESEARCH::SetXorKey(char *key)
|
|
|
603 {
|
|
|
604 unsigned short int i;
|
|
|
605 for (i=0; i < 16; i++)
|
|
|
606 xor_key[i] = key[i];
|
|
|
607 }
|
|
|
608
|
|
|
609 void FILESEARCH::GuessXorKey(char *regname)
|
|
|
610 {
|
|
|
611 char key1[16] = {
|
|
|
612 0xa8, 0x28, 0xfd, 0x66,
|
|
|
613 0xa0, 0x23, 0x77, 0x69,
|
|
|
614 0xf9, 0x45, 0xf8, 0x2c,
|
|
|
615 0x7c, 0x00, 0xad, 0xf4
|
|
|
616 };
|
|
|
617
|
|
|
618 char key2[16] = {
|
|
|
619 0xAF, 0x2F, 0xFB, 0x6B,
|
|
|
620 0xAF, 0x30, 0x77, 0x17,
|
|
|
621 0x87, 0x48, 0xFE, 0x2C,
|
|
|
622 0x68, 0x1A, 0xB9, 0xF0
|
|
|
623 };
|
|
|
624
|
|
|
625
|
|
|
626 if (strcmp(regname, "KEY\\CLANNAD_FV") == 0) {
|
|
|
627 SetXorKey(key2);
|
|
|
628 }
|
|
|
629 else {
|
|
|
630 SetXorKey(key1);
|
|
|
631 }
|
|
|
632 }
|
|
|
633
|
|
|
634 const char * FILESEARCH::GetXorKey(void)
|
|
|
635 {
|
|
|
636 return xor_key;
|
|
|
637 }
|
|
|
638
|
|
0
|
639 void FILESEARCH::SetFileInformation(FILETYPE tp, ARCTYPE is_arc, char* filename) {
|
|
|
640 int type = tp;
|
|
|
641 if (type < 0 || type >= TYPEMAX) return;
|
|
|
642 ARCFILE* next_arc = 0;
|
|
|
643 /* すでに searcher が存在すれば解放 */
|
|
|
644 if (searcher[type] != 0 &&
|
|
|
645 searcher[type] != root_dir &&
|
|
|
646 searcher[type] != dat_dir) {
|
|
|
647 next_arc = searcher[type]->Next();
|
|
|
648 delete searcher[type];
|
|
|
649 }
|
|
|
650 searcher[type] = 0;
|
|
|
651 /* 適当に初期化 */
|
|
|
652 if (filenames[type] != 0 &&
|
|
|
653 filenames[type] != default_dirnames[type]) delete[] filenames[type];
|
|
|
654 filenames[type] = new char[strlen(filename)+1];
|
|
|
655 strcpy(filenames[type], filename);
|
|
|
656 is_archived[type] = is_arc;
|
|
|
657 searcher[type] = MakeARCFILE(is_arc, filename);
|
|
|
658 if (searcher[type] && next_arc)
|
|
|
659 searcher[type]->SetNext(next_arc);
|
|
|
660 return;
|
|
|
661 }
|
|
|
662 void FILESEARCH::AppendFileInformation(FILETYPE tp, ARCTYPE is_arc, char* filename) {
|
|
|
663 int type = tp;
|
|
|
664 if (type < 0 || type >= TYPEMAX) return;
|
|
|
665 /* searcher がまだ割り当てられてない場合 */
|
|
|
666 if (searcher[type] == 0 ||
|
|
|
667 searcher[type] == root_dir ||
|
|
|
668 searcher[type] == dat_dir) {
|
|
|
669 searcher[type] = MakeARCFILE(is_archived[type], filenames[type]);
|
|
|
670 if (searcher[type] == 0) { /* 作成できなかった場合 */
|
|
|
671 /* この型情報を FileInformation とする */
|
|
|
672 SetFileInformation(tp, is_arc, filename);
|
|
|
673 return;
|
|
|
674 }
|
|
|
675 }
|
|
|
676 /* 初期化 */
|
|
|
677 ARCFILE* arc = MakeARCFILE(is_arc, filename);
|
|
|
678 /* append */
|
|
|
679 ARCFILE* cur;
|
|
|
680 for (cur=searcher[type]; cur->Next() != 0; cur = cur->Next()) ;
|
|
|
681 cur->SetNext(arc);
|
|
|
682 return;
|
|
|
683 }
|
|
|
684
|
|
|
685 ARCFILE* FILESEARCH::MakeARCFILE(ARCTYPE tp, char* filename) {
|
|
|
686 ARCFILE* arc = 0;
|
|
|
687 char* file;
|
|
|
688 if (filename == 0) goto err;
|
|
|
689 if (tp == ATYPE_DIR) {
|
|
|
690 file = root_dir->SearchFile(filename);
|
|
|
691 } else {
|
|
|
692 file = dat_dir->SearchFile(filename);
|
|
|
693 if (file == 0)
|
|
|
694 file = root_dir->SearchFile(filename);
|
|
|
695 }
|
|
|
696 if (file == 0) goto err;
|
|
|
697 switch(tp) {
|
|
|
698 case ATYPE_DIR: arc = new DIRFILE(file); break;
|
|
|
699 case ATYPE_SCN2k:
|
|
|
700 case ATYPE_ARC: {
|
|
|
701 FILE* f = fopen(file, "rb");
|
|
|
702 if (f == 0) goto err;
|
|
|
703 char header[32];
|
|
|
704 memset(header, 0, 32);
|
|
|
705 fread(header, 32, 1, f);
|
|
|
706 fclose(f);
|
|
|
707 char magic_raf[8] = {'C','A','P','F',1,0,0,0};
|
|
|
708 if (strncmp(header, "PACL", 4) == 0) arc = new ARCFILE(file);
|
|
|
709 else arc = new SCN2kFILE(file);
|
|
|
710 }
|
|
|
711 break;
|
|
|
712 default: fprintf(stderr,"FILESEARCH::MAKEARCFILE : invalid archive type; type %d name %s\n",tp,filename);
|
|
|
713 delete[] file;
|
|
|
714 goto err;
|
|
|
715 }
|
|
|
716 delete[] file;
|
|
|
717 return arc;
|
|
|
718 err:
|
|
|
719 arc = new NULFILE;
|
|
|
720 return arc;
|
|
|
721
|
|
|
722 }
|
|
|
723
|
|
|
724 ARCINFO* FILESEARCH::Find(FILETYPE type, const char* fname, const char* ext) {
|
|
|
725 if (searcher[type] == 0) {
|
|
|
726 /* searcher 作成 */
|
|
|
727 if (filenames[type] == 0) {
|
|
|
728 searcher[type] = dat_dir;
|
|
|
729 } else {
|
|
|
730 searcher[type] = MakeARCFILE(is_archived[type], filenames[type]);
|
|
|
731 if (searcher[type] == 0) {
|
|
|
732 fprintf(stderr,"FILESEARCH::Find : invalid archive type; type %d name %s\n",type,fname);
|
|
|
733 return 0;
|
|
|
734 }
|
|
|
735 }
|
|
|
736 }
|
|
|
737 return searcher[type]->Find(fname,ext);
|
|
|
738 }
|
|
|
739
|
|
|
740 char** FILESEARCH::ListAll(FILETYPE type) {
|
|
|
741 int i;
|
|
|
742 /* とりあえず searcher を初期化 */
|
|
|
743 Find(type, "THIS FILENAME MAY NOT EXIST IN THE FILE SYSTEM !!!");
|
|
|
744 if (searcher[type] == 0) return 0;
|
|
|
745 /* 全ファイルのリストアップ */
|
|
|
746 int deal = 0;
|
|
|
747 ARCFILE* file;
|
|
|
748 for (file = searcher[type]; file != 0; file = file->Next())
|
|
|
749 deal += file->Deal();
|
|
|
750 if (deal <= 0) return 0;
|
|
|
751 char** ret_list = new char*[deal+1];
|
|
|
752 int count = 0;
|
|
|
753 for (file = searcher[type]; file != 0; file = file->Next()) {
|
|
|
754 file->InitList();
|
|
|
755 char* f;
|
|
|
756 while( (f = file->ListItem() ) != 0) {
|
|
|
757 ret_list[count] = new char[strlen(f)+1];
|
|
|
758 strcpy(ret_list[count], f);
|
|
|
759 count++;
|
|
|
760 }
|
|
|
761 }
|
|
|
762 ret_list[count] = 0;
|
|
|
763 return ret_list;
|
|
|
764 }
|
|
|
765
|
|
|
766 ARCINFO::ARCINFO(const char* __arcname, ARCFILE_ATOM& atom) : info(atom) {
|
|
|
767 arcfile = new char[strlen(__arcname)+1];
|
|
|
768 strcpy(arcfile, __arcname);
|
|
|
769 use_mmap = false;
|
|
|
770 mmapped_memory = 0;
|
|
|
771 data = 0;
|
|
|
772 fd = -1;
|
|
|
773 }
|
|
|
774
|
|
|
775 ARCINFO::~ARCINFO() {
|
|
|
776 #ifdef HAVE_MMAP
|
|
|
777 if (mmapped_memory) munmap(mmapped_memory, info.arcsize);
|
|
|
778 #endif /* HAVE_MMAP */
|
|
|
779 if (fd != -1) close(fd);
|
|
|
780 if (data != mmapped_memory) delete[] data;
|
|
|
781 delete[] arcfile;
|
|
|
782 }
|
|
|
783
|
|
|
784 int ARCINFO::Size(void) const {
|
|
|
785 return info.filesize;
|
|
|
786 }
|
|
|
787
|
|
|
788 /* コピーを返す */
|
|
|
789 char* ARCINFO::CopyRead(void) {
|
|
|
790 const char* d = Read();
|
|
|
791 if (d == 0) return 0;
|
|
|
792 int s = Size();
|
|
|
793 if (s <= 0) return 0;
|
|
|
794 char* ret = new char[s]; memcpy(ret, d, s);
|
|
|
795 return ret;
|
|
|
796 }
|
|
|
797
|
|
|
798 const char* ARCINFO::Path(void) const {
|
|
|
799 if (info.offset != 0) return 0; /* archive file なのでパスを帰せない */
|
|
|
800 char* ret = new char[strlen(arcfile)+1];
|
|
|
801 strcpy(ret, arcfile);
|
|
|
802 return ret;
|
|
|
803 }
|
|
|
804 /* 互換性専用 */
|
|
|
805 FILE* ARCINFO::OpenFile(int* length) const {
|
|
|
806 FILE* f = fopen(arcfile, "rb");
|
|
|
807 if (info.offset) lseek(fileno(f), info.offset, SEEK_SET);
|
|
|
808 if (length) *length = info.arcsize;
|
|
|
809 return f;
|
|
|
810 }
|
|
|
811
|
|
|
812 // 展開処理はなし
|
|
|
813 bool ARCINFO::ExecExtract(void) {
|
|
|
814 return true;
|
|
|
815 }
|
|
|
816 /* 読み込みを開始する */
|
|
|
817 const char* ARCINFO::Read(void) {
|
|
|
818 // すでにデータを読み込み済みなら何もしない
|
|
|
819 if (data) return data;
|
|
|
820
|
|
|
821 if (info.offset < 0 || info.arcsize <= 0) {
|
|
|
822 return 0;
|
|
|
823 }
|
|
|
824 /* ファイルを開く */
|
|
|
825 fd = open(arcfile, O_RDONLY);
|
|
|
826 if (fd < 0) {
|
|
|
827 return 0;
|
|
|
828 }
|
|
|
829 if (lseek(fd, info.offset, 0) != info.offset) {
|
|
|
830 close(fd); fd = -1; return 0;
|
|
|
831 }
|
|
|
832 /* mmap を試みる */
|
|
|
833 #ifdef HAVE_MMAP
|
|
|
834 mmapped_memory = (char*)mmap(0, info.arcsize, PROT_READ, MAP_SHARED, fd, info.offset);
|
|
|
835 if (mmapped_memory != MAP_FAILED) {
|
|
|
836 use_mmap = true;
|
|
|
837 data = (const char*)mmapped_memory;
|
|
|
838 } else
|
|
|
839 #endif /* HAVE_MMAP */
|
|
|
840 {
|
|
|
841 /* 失敗：普通にファイルを読み込み */
|
|
|
842 char* d = new char[info.arcsize];
|
|
|
843 read(fd, d, info.arcsize);
|
|
|
844 close(fd);
|
|
|
845 fd = -1;
|
|
|
846 use_mmap = false;
|
|
|
847 data = d;
|
|
|
848 }
|
|
|
849 /* 展開する */
|
|
|
850 if (! ExecExtract()) {
|
|
|
851 // 失敗
|
|
|
852 #ifdef HAVE_MMAP
|
|
|
853 if (use_mmap) {
|
|
|
854 munmap(mmapped_memory, info.arcsize);
|
|
|
855 if (data == (const char*)mmapped_memory) data = 0;
|
|
|
856 }
|
|
|
857 #endif /* HAVE_MMAP */
|
|
|
858 delete[] (char*)data;
|
|
|
859 close(fd);
|
|
|
860 fd = -1; data = 0;
|
|
|
861 return 0;
|
|
|
862 }
|
|
|
863 #ifdef HAVE_MMAP
|
|
|
864 if (use_mmap && data != (const char*)mmapped_memory) {
|
|
|
865 // すでに mmap は必要ない
|
|
|
866 munmap(mmapped_memory, info.arcsize);
|
|
|
867 close(fd);
|
|
|
868 fd = -1;
|
|
|
869 use_mmap = false;
|
|
|
870 }
|
|
|
871 #endif /* HAVE_MMAP */
|
|
|
872 return data;
|
|
|
873 }
|
|
|
874
|
|
|
875 /**********************************************
|
|
|
876 **
|
|
|
877 ** 画像展開系クラスの定義、実装
|
|
|
878 **
|
|
|
879 ***********************************************
|
|
|
880 */
|
|
|
881 GRPCONV::GRPCONV(void) {
|
|
|
882 filename = 0;
|
|
|
883 data = 0;
|
|
|
884 }
|
|
|
885 GRPCONV::~GRPCONV() {
|
|
|
886 if (filename) delete[] filename;
|
|
|
887 }
|
|
|
888 void GRPCONV::Init(const char* f, const char* d, int dlen, int w, int h, bool is_m) {
|
|
|
889 if (filename) delete[] filename;
|
|
|
890 if (f == 0) {
|
|
|
891 char* fn = new char[1];
|
|
|
892 fn[0] = 0;
|
|
|
893 filename = fn;
|
|
|
894 } else {
|
|
|
895 char* fn = new char[strlen(f)+1];
|
|
|
896 strcpy(fn,f);
|
|
|
897 filename = fn;
|
|
|
898 }
|
|
|
899
|
|
|
900 data = d;
|
|
|
901 datalen = dlen;
|
|
|
902 width = w;
|
|
|
903 height = h;
|
|
|
904 is_mask = is_m;
|
|
|
905 }
|
|
|
906 class PDTCONV : public GRPCONV {
|
|
|
907 bool Read_PDT10(char* image);
|
|
|
908 bool Read_PDT11(char* image);
|
|
|
909 public:
|
|
|
910 PDTCONV(const char* _inbuf, int inlen, const char* fname);
|
|
|
911 ~PDTCONV() {}
|
|
|
912 bool Read(char* image);
|
|
|
913 };
|
|
|
914 class G00CONV : public GRPCONV {
|
|
|
915 struct REGION {
|
|
|
916 int x1, y1, x2, y2;
|
|
|
917 int Width() { return x2-x1+1;}
|
|
|
918 int Height() { return y2-y1+1;}
|
|
|
919 void FixVar(int& v, int& w) {
|
|
|
920 if (v < 0) v = 0;
|
|
|
921 if (v >= w) v = w-1;
|
|
|
922 }
|
|
|
923 void Fix(int w, int h) {
|
|
|
924 FixVar(x1,w);
|
|
|
925 FixVar(x2,w);
|
|
|
926 FixVar(y1,h);
|
|
|
927 FixVar(y2,h);
|
|
|
928 if (x1 > x2) x2 = x1;
|
|
|
929 if (y1 > y2) y2 = y1;
|
|
|
930 }
|
|
|
931 };
|
|
|
932
|
|
|
933 void Copy_16bpp(char* image, int x, int y, const char* src, int bpl, int h);
|
|
|
934 void Copy_32bpp(char* image, int x, int y, const char* src, int bpl, int h);
|
|
|
935 bool Read_Type0(char* image);
|
|
|
936 bool Read_Type1(char* image);
|
|
|
937 bool Read_Type2(char* image);
|
|
|
938 public:
|
|
|
939 G00CONV(const char* _inbuf, int _inlen, const char* fname);
|
|
|
940 ~G00CONV() { }
|
|
|
941 bool Read(char* image);
|
|
|
942 };
|
|
|
943
|
|
|
944 class BMPCONV : public GRPCONV {
|
|
|
945 public:
|
|
|
946 BMPCONV(const char* _inbuf, int _inlen, const char* fname);
|
|
|
947 ~BMPCONV() {};
|
|
|
948 bool Read(char* image);
|
|
|
949 };
|
|
|
950 #if HAVE_LIBPNG
|
|
|
951 class PNGCONV : public GRPCONV {
|
|
|
952 const char* png_data;
|
|
|
953 static void png_read(png_structp, png_bytep, png_size_t);
|
|
|
954
|
|
|
955 public:
|
|
|
956 PNGCONV(const char* _inbuf, int _inlen, const char* fname);
|
|
|
957 ~PNGCONV() {};
|
|
|
958 bool Read(char* image);
|
|
|
959 };
|
|
|
960 #endif
|
|
|
961
|
|
|
962 #if HAVE_LIBJPEG
|
|
|
963 class JPEGCONV : public GRPCONV {
|
|
|
964
|
|
|
965 public:
|
|
|
966 JPEGCONV(const char* _inbuf, int _inlen, const char* fname);
|
|
|
967 ~JPEGCONV() {};
|
|
|
968 bool Read(char* image);
|
|
|
969 void SetupSrc(struct jpeg_decompress_struct* cinfo, const char* data, int size);
|
|
|
970 static void init_source(j_decompress_ptr cinfo);
|
|
|
971 static boolean fill_input_buffer(j_decompress_ptr cinfo);
|
|
|
972 static void skip_input_data(j_decompress_ptr cinfo, long num_bytes);
|
|
|
973 static boolean resync_to_restart(j_decompress_ptr cinfo, int desired);
|
|
|
974 static void term_source(j_decompress_ptr cinf);
|
|
|
975 };
|
|
|
976 #endif
|
|
|
977
|
|
|
978 GRPCONV* GRPCONV::AssignConverter(const char* inbuf, int inlen, const char* fname) {
|
|
|
979 /* ファイルの内容に応じたコンバーターを割り当てる */
|
|
|
980 GRPCONV* conv = 0;
|
|
|
981 if (inlen < 10) return 0; /* invalid file */
|
|
|
982 if (conv == 0 && strncmp(inbuf, "PDT10", 5) == 0 || strncmp(inbuf, "PDT11", 5) == 0) { /* PDT10 or PDT11 */
|
|
|
983 conv = new PDTCONV(inbuf, inlen, fname);
|
|
|
984 if (conv->data == 0) { delete conv; conv = 0;}
|
|
|
985 }
|
|
|
986 #if HAVE_LIBPNG
|
|
|
987 unsigned char png_magic[4] = {0x89, 'P', 'N', 'G'};
|
|
|
988 if (conv == 0 && memcmp(inbuf, png_magic,4) == 0) {
|
|
|
989 conv = new PNGCONV(inbuf, inlen, fname);
|
|
|
990 if (conv->data == 0) { delete conv; conv = 0;}
|
|
|
991 }
|
|
|
992 #endif
|
|
|
993 #if HAVE_LIBJPEG
|
|
|
994 if ( conv == 0 && *(unsigned char*)inbuf == 0xff && *(unsigned char*)(inbuf+1) == 0xd8 &&
|
|
|
995 (strncmp(inbuf+6, "JFIF",4) == 0 || strncmp(inbuf+6,"Exif",4) == 0)) {
|
|
|
996 conv = new JPEGCONV(inbuf, inlen, fname);
|
|
|
997 if (conv->data == 0) { delete conv; conv = 0;}
|
|
|
998 }
|
|
|
999 #endif
|
|
|
1000 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
|
|
|
1001 conv = new BMPCONV(inbuf, inlen, fname);
|
|
|
1002 if (conv->data == 0) { delete conv; conv = 0;}
|
|
|
1003 }
|
|
|
1004 if (conv == 0 && (inbuf[0] == 0 || inbuf[0] == 1 || inbuf[0] == 2)) { /* G00 */
|
|
|
1005 conv = new G00CONV(inbuf, inlen, fname);
|
|
|
1006 if (conv->data == 0) { delete conv; conv = 0;}
|
|
|
1007 }
|
|
|
1008 return conv;
|
|
|
1009 }
|
|
|
1010
|
|
|
1011 PDTCONV::PDTCONV(const char* _inbuf, int _inlen,const char* filename) {
|
|
|
1012 // PDT FILE のヘッダ
|
|
|
1013 // +00 'PDT10' (PDT11 は未対応)
|
|
|
1014 // +08 ファイルサイズ (無視)
|
|
|
1015 // +0C width (ほぼすべて、640)
|
|
|
1016 // +10 height(ほぼすべて、480)
|
|
|
1017 // +14 (mask の) x 座標 (実際は無視・・・全ファイルで 0 )
|
|
|
1018 // +1c (mask の) y座標 (実際は無視 ・・・全ファイルで 0 )
|
|
|
1019 // +20 mask が存在すれば、mask へのポインタ
|
|
|
1020
|
|
|
1021 /* ヘッダチェック */
|
|
|
1022 if (_inlen < 0x20) {
|
|
|
1023 fprintf(stderr, "Invalid PDT file %s : size is too small\n",filename);
|
|
|
1024 return;
|
|
|
1025 }
|
|
|
1026 if (strncmp(_inbuf, "PDT10", 5) != 0 && strncmp(_inbuf, "PDT11", 5) != 0) {
|
|
|
1027 fprintf(stderr, "Invalid PDT file %s : not 'PDT10 / PDT11' file.\n", filename);
|
|
|
1028 return;
|
|
|
1029 }
|
|
|
1030 if (size_t(_inlen) != size_t(read_little_endian_int(_inbuf+0x08))) {
|
|
|
1031 fprintf(stderr, "Invalid archive file %s : invalid header.(size)\n",
|
|
|
1032 filename);
|
|
|
1033 return;
|
|
|
1034 }
|
|
|
1035
|
|
|
1036 int w = read_little_endian_int(_inbuf+0x0c);
|
|
|
1037 int h = read_little_endian_int(_inbuf+0x10);
|
|
|
1038 int mask_pt = read_little_endian_int(_inbuf + 0x1c);
|
|
|
1039 Init(filename, _inbuf, _inlen, w, h, mask_pt ? true : false);
|
|
|
1040
|
|
|
1041 return;
|
|
|
1042 }
|
|
|
1043
|
|
|
1044
|
|
|
1045 G00CONV::G00CONV(const char* _inbuf, int _inlen, const char* filename) {
|
|
|
1046 // G00 FILE のヘッダ
|
|
|
1047 // +00 type (1, 2)
|
|
|
1048 // +01: width(word)
|
|
|
1049 // +03: height(word)
|
|
|
1050 // type 1: (color table 付き LZ 圧縮 ; PDT11 に対応)
|
|
|
1051 // +05: 圧縮サイズ(dword) ; +5 するとデータ全体のサイズ
|
|
|
1052 // +09: 展開後サイズ(dword)
|
|
|
1053 // type 2: (マスク可、画像を矩形領域に分割してそれぞれ圧縮)
|
|
|
1054 // +05: index size
|
|
|
1055 // +09: index table(each size is 0x18)
|
|
|
1056 // +00
|
|
|
1057 //
|
|
|
1058 // +09+0x18*size+00: data size
|
|
|
1059 // +09+0x18*size+04: out size
|
|
|
1060 // +09+0x18*size+08: (data top)
|
|
|
1061 //
|
|
|
1062
|
|
|
1063 /* データから情報読み込み */
|
|
|
1064 int type = *_inbuf;
|
|
|
1065
|
|
|
1066 int w = read_little_endian_short(_inbuf+1);
|
|
|
1067 int h = read_little_endian_short(_inbuf+3);
|
|
|
1068 if (w < 0 || h < 0) return;
|
|
|
1069
|
|
|
1070 if (type == 0 || type == 1) { // color table 付き圧縮
|
|
|
1071 if (_inlen < 13) {
|
|
|
1072 fprintf(stderr, "Invalid G00 file %s : size is too small\n",filename);
|
|
|
1073 return;
|
|
|
1074 }
|
|
|
1075 int data_sz = read_little_endian_int(_inbuf+5);
|
|
|
1076
|
|
|
1077 if (_inlen != data_sz+5) {
|
|
|
1078 fprintf(stderr, "Invalid archive file %s : invalid header.(size)\n",
|
|
|
1079 filename);
|
|
|
1080 return;
|
|
|
1081 }
|
|
|
1082 Init(filename, _inbuf, _inlen, w, h, false);
|
|
|
1083 } else if (type == 2) { // color table なし、マスク付き可の圧縮
|
|
|
1084
|
|
|
1085 int head_size = read_little_endian_short(_inbuf+5);
|
|
|
1086 if (head_size < 0 || head_size*24 > _inlen) return;
|
|
|
1087
|
|
|
1088 const char* data_top = _inbuf + 9 + head_size*24;
|
|
|
1089 int data_sz = read_little_endian_int(data_top);
|
|
|
1090 if (_inbuf + _inlen != data_top + data_sz) {
|
|
|
1091 fprintf(stderr, "Invalid archive file %s : invalid header.(size)\n",
|
|
|
1092 filename);
|
|
|
1093 return;
|
|
|
1094 }
|
|
|
1095 Init(filename, _inbuf, _inlen, w, h, true);
|
|
|
1096 }
|
|
|
1097 return;
|
|
|
1098 }
|
|
|
1099
|
|
|
1100 bool G00CONV::Read(char* image) {
|
|
|
1101 if (data == 0) return false;
|
|
|
1102 /* header 識別 */
|
|
|
1103 int type = *data;
|
|
|
1104 if (type == 0) return Read_Type0(image);
|
|
|
1105 else if (type == 1) return Read_Type1(image);
|
|
|
1106 else if (type == 2) return Read_Type2(image);
|
|
|
1107 }
|
|
|
1108
|
|
|
1109 /* 一般的な LZ 圧縮の展開ルーチン */
|
|
|
1110 /* datasize はデータの大きさ、char / short / int を想定 */
|
|
|
1111 /* datatype は Copy1Pixel (1データのコピー)及び ExtractData(LZ 圧縮の情報を得る
|
|
|
1112 ** というメソッドを実装したクラス */
|
|
|
1113 static int bitrev_table[256] = {
|
|
|
1114 0x00, 0x80, 0x40, 0xc0, 0x20, 0xa0, 0x60, 0xe0, 0x10, 0x90, 0x50, 0xd0, 0x30, 0xb0, 0x70, 0xf0,
|
|
|
1115 0x08, 0x88, 0x48, 0xc8, 0x28, 0xa8, 0x68, 0xe8, 0x18, 0x98, 0x58, 0xd8, 0x38, 0xb8, 0x78, 0xf8,
|
|
|
1116 0x04, 0x84, 0x44, 0xc4, 0x24, 0xa4, 0x64, 0xe4, 0x14, 0x94, 0x54, 0xd4, 0x34, 0xb4, 0x74, 0xf4,
|
|
|
1117 0x0c, 0x8c, 0x4c, 0xcc, 0x2c, 0xac, 0x6c, 0xec, 0x1c, 0x9c, 0x5c, 0xdc, 0x3c, 0xbc, 0x7c, 0xfc,
|
|
|
1118 0x02, 0x82, 0x42, 0xc2, 0x22, 0xa2, 0x62, 0xe2, 0x12, 0x92, 0x52, 0xd2, 0x32, 0xb2, 0x72, 0xf2,
|
|
|
1119 0x0a, 0x8a, 0x4a, 0xca, 0x2a, 0xaa, 0x6a, 0xea, 0x1a, 0x9a, 0x5a, 0xda, 0x3a, 0xba, 0x7a, 0xfa,
|
|
|
1120 0x06, 0x86, 0x46, 0xc6, 0x26, 0xa6, 0x66, 0xe6, 0x16, 0x96, 0x56, 0xd6, 0x36, 0xb6, 0x76, 0xf6,
|
|
|
1121 0x0e, 0x8e, 0x4e, 0xce, 0x2e, 0xae, 0x6e, 0xee, 0x1e, 0x9e, 0x5e, 0xde, 0x3e, 0xbe, 0x7e, 0xfe,
|
|
|
1122 0x01, 0x81, 0x41, 0xc1, 0x21, 0xa1, 0x61, 0xe1, 0x11, 0x91, 0x51, 0xd1, 0x31, 0xb1, 0x71, 0xf1,
|
|
|
1123 0x09, 0x89, 0x49, 0xc9, 0x29, 0xa9, 0x69, 0xe9, 0x19, 0x99, 0x59, 0xd9, 0x39, 0xb9, 0x79, 0xf9,
|
|
|
1124 0x05, 0x85, 0x45, 0xc5, 0x25, 0xa5, 0x65, 0xe5, 0x15, 0x95, 0x55, 0xd5, 0x35, 0xb5, 0x75, 0xf5,
|
|
|
1125 0x0d, 0x8d, 0x4d, 0xcd, 0x2d, 0xad, 0x6d, 0xed, 0x1d, 0x9d, 0x5d, 0xdd, 0x3d, 0xbd, 0x7d, 0xfd,
|
|
|
1126 0x03, 0x83, 0x43, 0xc3, 0x23, 0xa3, 0x63, 0xe3, 0x13, 0x93, 0x53, 0xd3, 0x33, 0xb3, 0x73, 0xf3,
|
|
|
1127 0x0b, 0x8b, 0x4b, 0xcb, 0x2b, 0xab, 0x6b, 0xeb, 0x1b, 0x9b, 0x5b, 0xdb, 0x3b, 0xbb, 0x7b, 0xfb,
|
|
|
1128 0x07, 0x87, 0x47, 0xc7, 0x27, 0xa7, 0x67, 0xe7, 0x17, 0x97, 0x57, 0xd7, 0x37, 0xb7, 0x77, 0xf7,
|
|
|
1129 0x0f, 0x8f, 0x4f, 0xcf, 0x2f, 0xaf, 0x6f, 0xef, 0x1f, 0x9f, 0x5f, 0xdf, 0x3f, 0xbf, 0x7f, 0xff};
|
|
|
1130 template<class DataType, class DataSize> inline int lzExtract(DataType& datatype,const char*& src, char*& dest, const char* srcend, char* destend) {
|
|
|
1131 int count = 0;
|
|
|
1132 const char* lsrcend = srcend; char* ldestend = destend;
|
|
|
1133 const char* lsrc = src; char* ldest = dest;
|
|
|
1134
|
|
|
1135 if (lsrc+50 < lsrcend && ldest+1024 < ldestend) {
|
|
|
1136 /* まず、範囲チェックを緩くして高速なルーチンを使う */
|
|
|
1137 lsrcend -= 50;
|
|
|
1138 ldestend += 1024;
|
|
|
1139 while (ldest < ldestend && lsrc < lsrcend) {
|
|
|
1140 count += 8;
|
|
|
1141 int flag = int(*(unsigned char*)lsrc++);
|
|
|
1142 if (datatype.IsRev()) flag = bitrev_table[flag];
|
|
|
1143 int i; for (i=0; i<8; i++) {
|
|
|
1144 if (flag & 0x80) {
|
|
|
1145 datatype.Copy1Pixel(lsrc, ldest);
|
|
|
1146 } else {
|
|
|
1147 int data, size;
|
|
|
1148 datatype.ExtractData(lsrc, data, size);
|
|
|
1149 DataSize* p_dest = ((DataSize*)ldest) - data;
|
|
|
1150 int k; for (k=0; k<size; k++) {
|
|
|
1151 p_dest[data] = *p_dest;
|
|
|
1152 p_dest++;
|
|
|
1153 }
|
|
|
1154 ldest += size*sizeof(DataSize);
|
|
|
1155 }
|
|
|
1156 flag <<= 1;
|
|
|
1157 }
|
|
|
1158 }
|
|
|
1159 lsrcend += 50;
|
|
|
1160 ldestend += 1024;
|
|
|
1161 }
|
|
|
1162 /* 残りを変換 */
|
|
|
1163 while (ldest < ldestend && lsrc < lsrcend) {
|
|
|
1164 count += 8;
|
|
|
1165 int flag = int(*(unsigned char*)lsrc++);
|
|
|
1166 if (datatype.IsRev()) flag = bitrev_table[flag];
|
|
|
1167 int i; for (i=0; i<8 && ldest < ldestend && lsrc < lsrcend; i++) {
|
|
|
1168 if (flag & 0x80) {
|
|
|
1169 datatype.Copy1Pixel(lsrc, ldest);
|
|
|
1170 } else {
|
|
|
1171 int data, size;
|
|
|
1172 datatype.ExtractData(lsrc, data, size);
|
|
|
1173 DataSize* p_dest = ((DataSize*)ldest) - data;
|
|
|
1174 int k; for (k=0; k<size; k++) {
|
|
|
1175 p_dest[data] = *p_dest;
|
|
|
1176 p_dest++;
|
|
|
1177 }
|
|
|
1178 ldest += size*sizeof(DataSize);
|
|
|
1179 }
|
|
|
1180 flag <<= 1;
|
|
|
1181 }
|
|
|
1182 }
|
|
|
1183 dest=ldest; src=lsrc;
|
|
|
1184 return 0;
|
|
|
1185 }
|
|
|
1186 /* 引数を減らすためのwrapper */
|
|
|
1187 template<class DataType, class DataSize> inline int lzExtract(DataType datatype, DataSize datasize ,const char*& src, char*& dest, const char* srcend, char* destend) {
|
|
|
1188 return lzExtract<DataType, DataSize>(datatype,src,dest,srcend,destend);
|
|
|
1189 }
|
|
|
1190
|
|
|
1191 /* 普通の PDT */
|
|
|
1192 class Extract_DataType {
|
|
|
1193 public:
|
|
|
1194 static void ExtractData(const char*& lsrc, int& data, int& size) {
|
|
|
1195 data = read_little_endian_short(lsrc) & 0xffff;
|
|
|
1196 size = (data & 0x0f) + 1;
|
|
|
1197 data = (data>>4)+1;
|
|
|
1198 lsrc += 2;
|
|
|
1199 }
|
|
|
1200 static void Copy1Pixel(const char*& lsrc, char*& ldest) {
|
|
|
1201 #ifdef WORDS_BIGENDIAN
|
|
|
1202 ldest[3] = lsrc[0];
|
|
|
1203 ldest[2] = lsrc[1];
|
|
|
1204 ldest[1] = lsrc[2];
|
|
|
1205 ldest[0] = 0;
|
|
|
1206 #else
|
|
|
1207 *(int*)ldest = read_little_endian_int(lsrc); ldest[3]=0;
|
|
|
1208 #endif
|
|
|
1209 lsrc += 3; ldest += 4;
|
|
|
1210 }
|
|
|
1211 static int IsRev(void) { return 0; }
|
|
|
1212 };
|
|
|
1213
|
|
|
1214 /* PDT11 の第一段階変換 */
|
|
|
1215 class Extract_DataType_PDT11 {
|
|
|
1216 int* index_table;
|
|
|
1217 public:
|
|
|
1218 Extract_DataType_PDT11(int* it) { index_table = it; }
|
|
|
1219 void ExtractData(const char*& lsrc, int& data, int& size) {
|
|
|
1220 data = int(*(const unsigned char*)lsrc);
|
|
|
1221 size = (data>>4) + 2;
|
|
|
1222 data = index_table[data&0x0f];
|
|
|
1223 lsrc++;
|
|
|
1224 }
|
|
|
1225 static void Copy1Pixel(const char*& lsrc, char*& ldest) {
|
|
|
1226 *ldest = *lsrc;
|
|
|
1227 ldest++; lsrc++;
|
|
|
1228 }
|
|
|
1229 static int IsRev(void) { return 0; }
|
|
|
1230 };
|
|
|
1231 /* マスク用 */
|
|
|
1232 class Extract_DataType_Mask {
|
|
|
1233 public:
|
|
|
1234 void ExtractData(const char*& lsrc, int& data, int& size) {
|
|
|
1235 int d = read_little_endian_short(lsrc) & 0xffff;
|
|
|
1236 size = (d & 0xff) + 2;
|
|
|
1237 data = (d>>8)+1;
|
|
|
1238 lsrc += 2;
|
|
|
1239 }
|
|
|
1240 static void Copy1Pixel(const char*& lsrc, char*& ldest) {
|
|
|
1241 *ldest = *lsrc;
|
|
|
1242 ldest++; lsrc++;
|
|
|
1243 }
|
|
|
1244 static int IsRev(void) { return 0; }
|
|
|
1245 };
|
|
|
1246 /* 書庫用 */
|
|
|
1247 class Extract_DataType_ARC {
|
|
|
1248 public:
|
|
|
1249 void ExtractData(const char*& lsrc, int& data, int& size) {
|
|
|
1250 data = read_little_endian_short(lsrc) & 0xffff;
|
|
|
1251 size = (data&0x0f) + 2;
|
|
|
1252 data = (data>>4) + 1;
|
|
|
1253 lsrc+= 2;
|
|
|
1254 }
|
|
|
1255 static void Copy1Pixel(const char*& lsrc, char*& ldest) {
|
|
|
1256 *ldest = *lsrc;
|
|
|
1257 ldest++; lsrc++;
|
|
|
1258 }
|
|
|
1259 static int IsRev(void) { return 0; }
|
|
|
1260 };
|
|
|
1261 /* avg2000 のシナリオ用 */
|
|
|
1262 class Extract_DataType_SCN2k {
|
|
|
1263 public:
|
|
|
1264 void ExtractData(const char*& lsrc, int& data, int& size) {
|
|
|
1265 data = read_little_endian_short(lsrc) & 0xffff;
|
|
|
1266 size = (data&0x0f) + 2;
|
|
|
1267 data = (data>>4);
|
|
|
1268 lsrc+= 2;
|
|
|
1269 }
|
|
|
1270 static void Copy1Pixel(const char*& lsrc, char*& ldest) {
|
|
|
1271 *ldest = *lsrc;
|
|
|
1272 ldest++; lsrc++;
|
|
|
1273 }
|
|
|
1274 static int IsRev(void) { return 1; }
|
|
|
1275 };
|
|
|
1276 /* ReadLive の type0 */
|
|
|
1277 class Extract_DataType_G00Type0 {
|
|
|
1278 public:
|
|
|
1279 static void ExtractData(const char*& lsrc, int& data, int& size) {
|
|
|
1280 data = read_little_endian_short(lsrc) & 0xffff;
|
|
|
1281 size = ((data & 0x0f)+ 1) * 3;
|
|
|
1282 data = (data>>4) * 3;
|
|
|
1283 lsrc += 2;
|
|
|
1284 }
|
|
|
1285 static void Copy1Pixel(const char*& lsrc, char*& ldest) {
|
|
|
1286 #ifdef WORDS_BIGENDIAN
|
|
|
1287 ldest[0] = lsrc[0];
|
|
|
1288 ldest[1] = lsrc[1];
|
|
|
1289 ldest[2] = lsrc[2];
|
|
|
1290 #else /* LITTLE ENDIAN / intel architecture */
|
|
|
1291 *(int*)ldest = *(int*)lsrc;
|
|
|
1292 #endif
|
|
|
1293 lsrc += 3; ldest += 3;
|
|
|
1294 }
|
|
|
1295 static int IsRev(void) { return 1; }
|
|
|
1296 };
|
|
|
1297
|
|
|
1298
|
|
|
1299 bool PDTCONV::Read(char* image) {
|
|
|
1300 if (data == 0) return false;
|
|
|
1301
|
|
|
1302 if (strncmp(data, "PDT10", 5) == 0) {
|
|
|
1303 if (! Read_PDT10(image)) return false;
|
|
|
1304 } else if (strncmp(data, "PDT11", 5) == 0) {
|
|
|
1305 if (! Read_PDT11(image)) return false;
|
|
|
1306 }
|
|
|
1307 if (! is_mask) return true;
|
|
|
1308 // マスク読み込み
|
|
|
1309 int mask_pt = read_little_endian_int(data + 0x1c);
|
|
|
1310 char* buf = new char[width*height+1024];
|
|
|
1311 const char* src = data + mask_pt;
|
|
|
1312 const char* srcend = data + datalen;
|
|
|
1313 char* dest = buf;
|
|
|
1314 char* destend = buf + width*height;
|
|
|
1315 while(lzExtract(Extract_DataType_Mask(), char(), src, dest, srcend, destend)) ;
|
|
|
1316 int i; int len = width*height;
|
|
|
1317 src = buf; dest = image;
|
|
|
1318 for (i=0; i<len; i++) {
|
|
|
1319 *(int*)dest |= int(*(unsigned char*)src) << 24;
|
|
|
1320 src++;
|
|
|
1321 dest += 4;
|
|
|
1322 }
|
|
|
1323 delete[] buf;
|
|
|
1324 return true;
|
|
|
1325 }
|
|
|
1326
|
|
|
1327
|
|
|
1328 bool PDTCONV::Read_PDT10(char* image) {
|
|
|
1329 int mask_pt = read_little_endian_int(data + 0x1c);
|
|
|
1330
|
|
|
1331 const char* src = data + 0x20;
|
|
|
1332 const char* srcend;
|
|
|
1333 if (mask_pt == 0) srcend = data + datalen;
|
|
|
1334 else srcend = data + mask_pt;
|
|
|
1335
|
|
|
1336 char* dest = image;
|
|
|
1337 char* destend;
|
|
|
1338
|
|
|
1339 destend = image + width*height*4;
|
|
|
1340 while(lzExtract(Extract_DataType(), int(), src, dest, srcend, destend)) ;
|
|
|
1341 return true;
|
|
|
1342 }
|
|
|
1343 bool PDTCONV::Read_PDT11(char* image) {
|
|
|
1344 int index_table[16];
|
|
|
1345 int color_table[256];
|
|
|
1346 int i;
|
|
|
1347 for (i=0; i<16; i++)
|
|
|
1348 index_table[i] = read_little_endian_int(data + 0x420 + i*4);
|
|
|
1349
|
|
|
1350 int mask_pt = read_little_endian_int(data + 0x1c);
|
|
|
1351
|
|
|
1352 const char* src = data + 0x460;
|
|
|
1353 const char* srcend;
|
|
|
1354 if (mask_pt == 0) srcend = data + datalen;
|
|
|
1355 else srcend = data + mask_pt;
|
|
|
1356
|
|
|
1357 char* dest = image;
|
|
|
1358 char* destend = image + width*height;
|
|
|
1359
|
|
|
1360 while(lzExtract(Extract_DataType_PDT11(index_table), char(), src, dest, srcend, destend)) ;
|
|
|
1361
|
|
|
1362 const char* cur = data + 0x20;
|
|
|
1363 for (i=0; i<256; i++) {
|
|
|
1364 color_table[i] = read_little_endian_int(cur);
|
|
|
1365 cur += 4;
|
|
|
1366 }
|
|
|
1367 src = image + width*height;
|
|
|
1368 int* desti = (int*)(image + width*height*4);
|
|
|
1369 while(desti != (int*)image)
|
|
|
1370 *--desti = color_table[*(unsigned char*)--src];
|
|
|
1371 return true;
|
|
|
1372 }
|
|
|
1373
|
|
|
1374 /* dest は dest_end よりも 256 byte 以上先まで
|
|
|
1375 ** 書き込み可能であること。
|
|
|
1376 */
|
|
|
1377 void ARCINFO::Extract(char*& dest_start, char*& src_start, char* dest_end, char* src_end) {
|
|
|
1378 const char* src = src_start;
|
|
|
1379 while (lzExtract(Extract_DataType_ARC(), char(), src, dest_start, src_end, dest_end)) ;
|
|
|
1380 src_start = (char*)src;
|
|
|
1381 return;
|
|
|
1382 }
|
|
|
1383 void ARCINFO::Extract2k(char*& dest_start, char*& src_start, char* dest_end, char* src_end) {
|
|
|
1384 const char* src = src_start;
|
|
|
1385 while (lzExtract(Extract_DataType_SCN2k(), char(), src, dest_start, src_end, dest_end)) ;
|
|
|
1386 src_start = (char*)src;
|
|
|
1387 return;
|
|
|
1388 }
|
|
|
1389
|
|
|
1390 bool ARCINFO_AVG32::ExecExtract(void) {
|
|
|
1391 // ヘッダのチェック
|
|
|
1392 if (strncmp(data, "PACK", 4) != 0) return false;
|
|
|
1393 if (read_little_endian_int(data+8) != info.filesize) return false;
|
|
|
1394 if (read_little_endian_int(data+12) != info.arcsize) return false;
|
|
|
1395
|
|
|
1396 // ファイルを展開する
|
|
|
1397 char* ret_data = new char[info.filesize+1024];
|
|
|
1398
|
|
|
1399 const char* s = data + 0x10;
|
|
|
1400 const char* send = data + info.arcsize;
|
|
|
1401 char* d = ret_data;
|
|
|
1402 char* dend = ret_data + info.filesize;
|
|
|
1403 while(lzExtract(Extract_DataType_ARC(), char(), s, d, send, dend)) ;
|
|
|
1404 if (! use_mmap) delete[] data;
|
|
|
1405 data = ret_data;
|
|
|
1406 return true;
|
|
|
1407 }
|
|
|
1408
|
|
|
1409 char ARCINFO2k::decode_seed[256] ={
|
|
|
1410 0x8b ,0xe5 ,0x5d ,0xc3 ,0xa1 ,0xe0 ,0x30 ,0x44 ,0x00 ,0x85 ,0xc0 ,0x74 ,0x09 ,0x5f ,0x5e ,0x33
|
|
|
1411 ,0xc0 ,0x5b ,0x8b ,0xe5 ,0x5d ,0xc3 ,0x8b ,0x45 ,0x0c ,0x85 ,0xc0 ,0x75 ,0x14 ,0x8b ,0x55 ,0xec
|
|
|
1412 ,0x83 ,0xc2 ,0x20 ,0x52 ,0x6a ,0x00 ,0xe8 ,0xf5 ,0x28 ,0x01 ,0x00 ,0x83 ,0xc4 ,0x08 ,0x89 ,0x45
|
|
|
1413 ,0x0c ,0x8b ,0x45 ,0xe4 ,0x6a ,0x00 ,0x6a ,0x00 ,0x50 ,0x53 ,0xff ,0x15 ,0x34 ,0xb1 ,0x43 ,0x00
|
|
|
1414 ,0x8b ,0x45 ,0x10 ,0x85 ,0xc0 ,0x74 ,0x05 ,0x8b ,0x4d ,0xec ,0x89 ,0x08 ,0x8a ,0x45 ,0xf0 ,0x84
|
|
|
1415 ,0xc0 ,0x75 ,0x78 ,0xa1 ,0xe0 ,0x30 ,0x44 ,0x00 ,0x8b ,0x7d ,0xe8 ,0x8b ,0x75 ,0x0c ,0x85 ,0xc0
|
|
|
1416 ,0x75 ,0x44 ,0x8b ,0x1d ,0xd0 ,0xb0 ,0x43 ,0x00 ,0x85 ,0xff ,0x76 ,0x37 ,0x81 ,0xff ,0x00 ,0x00
|
|
|
1417 ,0x04 ,0x00 ,0x6a ,0x00 ,0x76 ,0x43 ,0x8b ,0x45 ,0xf8 ,0x8d ,0x55 ,0xfc ,0x52 ,0x68 ,0x00 ,0x00
|
|
|
1418 ,0x04 ,0x00 ,0x56 ,0x50 ,0xff ,0x15 ,0x2c ,0xb1 ,0x43 ,0x00 ,0x6a ,0x05 ,0xff ,0xd3 ,0xa1 ,0xe0
|
|
|
1419 ,0x30 ,0x44 ,0x00 ,0x81 ,0xef ,0x00 ,0x00 ,0x04 ,0x00 ,0x81 ,0xc6 ,0x00 ,0x00 ,0x04 ,0x00 ,0x85
|
|
|
1420 ,0xc0 ,0x74 ,0xc5 ,0x8b ,0x5d ,0xf8 ,0x53 ,0xe8 ,0xf4 ,0xfb ,0xff ,0xff ,0x8b ,0x45 ,0x0c ,0x83
|
|
|
1421 ,0xc4 ,0x04 ,0x5f ,0x5e ,0x5b ,0x8b ,0xe5 ,0x5d ,0xc3 ,0x8b ,0x55 ,0xf8 ,0x8d ,0x4d ,0xfc ,0x51
|
|
|
1422 ,0x57 ,0x56 ,0x52 ,0xff ,0x15 ,0x2c ,0xb1 ,0x43 ,0x00 ,0xeb ,0xd8 ,0x8b ,0x45 ,0xe8 ,0x83 ,0xc0
|
|
|
1423 ,0x20 ,0x50 ,0x6a ,0x00 ,0xe8 ,0x47 ,0x28 ,0x01 ,0x00 ,0x8b ,0x7d ,0xe8 ,0x89 ,0x45 ,0xf4 ,0x8b
|
|
|
1424 ,0xf0 ,0xa1 ,0xe0 ,0x30 ,0x44 ,0x00 ,0x83 ,0xc4 ,0x08 ,0x85 ,0xc0 ,0x75 ,0x56 ,0x8b ,0x1d ,0xd0
|
|
|
1425 ,0xb0 ,0x43 ,0x00 ,0x85 ,0xff ,0x76 ,0x49 ,0x81 ,0xff ,0x00 ,0x00 ,0x04 ,0x00 ,0x6a ,0x00 ,0x76};
|
|
30
|
1426
|
|
0
|
1427
|
|
|
1428 bool ARCINFO2k::ExecExtract(void) {
|
|
|
1429 int i;
|
|
|
1430 char* ret_data = new char[info.filesize + 1024];
|
|
|
1431 char* decoded_data = new char[info.arcsize + 1024];
|
|
|
1432
|
|
|
1433 /* header のコピー */
|
|
|
1434 memcpy(ret_data, data, info.private_data);
|
|
|
1435
|
|
|
1436 /* まず、xor の暗号化を解く */
|
|
|
1437 const char* s; const char* send;
|
|
|
1438 char* d; char* dend;
|
|
|
1439
|
|
|
1440 s = data + info.private_data;
|
|
|
1441 send = data + info.arcsize;
|
|
|
1442 d = decoded_data + info.private_data;
|
|
|
1443 dend = decoded_data + info.arcsize;
|
|
|
1444 i = 0;
|
|
|
1445 while(s != send)
|
|
|
1446 *d++ = *s++ ^ decode_seed[(i++)&0xff];
|
|
|
1447
|
|
|
1448 if (info.filesize == info.arcsize) {
|
|
|
1449 memcpy(ret_data+info.private_data, decoded_data + info.private_data + 8, info.arcsize - info.private_data - 8);
|
|
|
1450 } else {
|
|
|
1451 /* 圧縮されているなら、それを展開 */
|
|
|
1452 s = (const char*)(decoded_data + info.private_data + 8);
|
|
|
1453 send = (const char*)(decoded_data + info.arcsize);
|
|
|
1454 d = ret_data + info.private_data;
|
|
|
1455 dend = ret_data + info.filesize;
|
|
|
1456 while(lzExtract(Extract_DataType_SCN2k(), char(), s, d, send, dend)) ;
|
|
|
1457 }
|
|
|
1458 if (read_little_endian_int(data+4) == 0x1adb2) { // Little Busters!
|
|
30
|
1459 const char *decode_key = file_searcher.GetXorKey();
|
|
0
|
1460 int header_size = info.private_data;
|
|
|
1461 for (i=0x100; i<=0x200 && header_size+i < info.filesize; i++) {
|
|
30
|
1462 ret_data[header_size+i] ^= decode_key[i&0x0f];
|
|
0
|
1463 }
|
|
|
1464 }
|
|
|
1465 delete[] decoded_data;
|
|
|
1466 if (! use_mmap) delete[] data;
|
|
|
1467 data = ret_data;
|
|
|
1468 return true;
|
|
|
1469 }
|
|
|
1470
|
|
|
1471 bool G00CONV::Read_Type0(char* image) {
|
|
|
1472 int uncompress_size = read_little_endian_int(data+9);
|
|
|
1473 char* uncompress_data = new char[uncompress_size+1024];
|
|
|
1474
|
|
|
1475 // まず展開
|
|
|
1476 const char* src = data + 13;
|
|
|
1477 const char* srcend = data + datalen;
|
|
|
1478 char* dest = uncompress_data;
|
|
|
1479 char* dstend = uncompress_data + uncompress_size;
|
|
|
1480 while(lzExtract(Extract_DataType_G00Type0(), char(), src, dest, srcend, dstend));
|
|
|
1481 // image にコピー
|
|
|
1482 CopyRGB(image, uncompress_data);
|
|
|
1483 delete[] uncompress_data;
|
|
|
1484 return true;
|
|
|
1485 }
|
|
|
1486 bool G00CONV::Read_Type1(char* image) {
|
|
|
1487 int i;
|
|
|
1488 int uncompress_size = read_little_endian_int(data+9) + 1;
|
|
|
1489 char* uncompress_data = new char[uncompress_size + 1024];
|
|
|
1490
|
|
|
1491 // まず、展開
|
|
|
1492 const char* src = data + 13;
|
|
|
1493 const char* srcend = data + datalen;
|
|
|
1494 char* dest = uncompress_data;
|
|
|
1495 char* destend = uncompress_data + uncompress_size;
|
|
|
1496
|
|
|
1497 while(lzExtract(Extract_DataType_SCN2k(), char(), src, dest, srcend, destend));
|
|
|
1498
|
|
|
1499 int colortable[256];
|
|
|
1500 memset(colortable, 0, sizeof(int)*256);
|
|
|
1501 int colortable_len = read_little_endian_short(uncompress_data);
|
|
|
1502 if (colortable_len > 256) colortable_len = 256;
|
|
|
1503 if (colortable_len < 0) colortable_len = 0;
|
|
|
1504 for (i=0; i<colortable_len; i++) {
|
|
|
1505 colortable[i] = read_little_endian_int(uncompress_data+2+i*4);
|
|
|
1506 }
|
|
|
1507 src = uncompress_data + 2 + read_little_endian_short(uncompress_data)*4;
|
|
|
1508 srcend = uncompress_data + uncompress_size;
|
|
|
1509 dest = image; destend = image + width*height*4;
|
|
|
1510 while(dest < destend && src < srcend) {
|
|
|
1511 *(int*)dest = colortable[*(unsigned char*)src];
|
|
|
1512 dest += 4; src ++;
|
|
|
1513 }
|
|
|
1514 delete[] uncompress_data;
|
|
|
1515 return true;
|
|
|
1516 }
|
|
|
1517
|
|
|
1518 bool G00CONV::Read_Type2(char* image) {
|
|
|
1519 memset(image, 0, width*height*4);
|
|
|
1520 /* 分割領域を得る */
|
|
|
1521 int region_deal = read_little_endian_int(data+5);
|
|
|
1522 REGION* region_table = new REGION[region_deal];
|
|
|
1523
|
|
|
1524 const char* head = data + 9;
|
|
|
1525 int i; for (i=0; i<region_deal; i++) {
|
|
|
1526 region_table[i].x1 = read_little_endian_int(head+0);
|
|
|
1527 region_table[i].y1 = read_little_endian_int(head+4);
|
|
|
1528 region_table[i].x2 = read_little_endian_int(head+8);
|
|
|
1529 region_table[i].y2 = read_little_endian_int(head+12);
|
|
|
1530 region_table[i].Fix(width, height);
|
|
|
1531 head += 24;
|
|
|
1532 }
|
|
|
1533
|
|
|
1534 // 展開
|
|
|
1535 int uncompress_size = read_little_endian_int(head+4);
|
|
|
1536 char* uncompress_data = new char[uncompress_size + 1024];
|
|
|
1537
|
|
|
1538 const char* src = head + 8;
|
|
|
1539 const char* srcend = data + datalen;
|
|
|
1540 char* dest = uncompress_data;
|
|
|
1541 char* destend = uncompress_data + uncompress_size;
|
|
|
1542 while(lzExtract(Extract_DataType_SCN2k(), char(), src, dest, srcend, destend));
|
|
|
1543
|
|
|
1544 /* region_deal2 == region_deal のはず……*/
|
|
|
1545 int region_deal2 = read_little_endian_int(uncompress_data);
|
|
|
1546 if (region_deal > region_deal2) region_deal = region_deal2;
|
|
|
1547
|
|
|
1548 for (i=0; i < region_deal; i++) {
|
|
|
1549 int offset = read_little_endian_int(uncompress_data + i*8 + 4);
|
|
|
1550 int length = read_little_endian_int(uncompress_data + i*8 + 8);
|
|
|
1551 src = (const char*)(uncompress_data + offset + 0x74);
|
|
|
1552 srcend = (const char*)(uncompress_data + offset + length);
|
|
|
1553 while(src < srcend) {
|
|
|
1554 int x, y, w, h;
|
|
|
1555 /* コピーする領域を得る */
|
|
|
1556 x = read_little_endian_short(src);
|
|
|
1557 y = read_little_endian_short(src+2);
|
|
|
1558 w = read_little_endian_short(src+6);
|
|
|
1559 h = read_little_endian_short(src+8);
|
|
|
1560 src += 0x5c;
|
|
|
1561
|
|
|
1562 x += region_table[i].x1;
|
|
|
1563 y += region_table[i].y1;
|
|
|
1564
|
|
|
1565 Copy_32bpp(image, x, y, src, w*4, h);
|
|
|
1566
|
|
|
1567 src += w*h*4;
|
|
|
1568 }
|
|
|
1569 }
|
|
|
1570 delete[] uncompress_data;
|
|
7
|
1571 delete[] region_table;
|
|
0
|
1572 return true;
|
|
|
1573 }
|
|
|
1574
|
|
|
1575 void G00CONV::Copy_32bpp(char* image, int x, int y, const char* src, int bpl, int h) {
|
|
|
1576 int i;
|
|
|
1577 int* dest = (int*)(image + x*4 + y*4*width);
|
|
|
1578 int w = bpl / 4;
|
|
|
1579 for (i=0; i<h; i++) {
|
|
|
1580 const char* s = src;
|
|
|
1581 int* d = dest;
|
|
|
1582 int j; for (j=0; j<w; j++) {
|
|
|
1583 *d++ = read_little_endian_int(s);
|
|
|
1584 s += 4;
|
|
|
1585 }
|
|
|
1586 src += bpl; dest += width;
|
|
|
1587 }
|
|
|
1588 }
|
|
|
1589
|
|
|
1590 void GRPCONV::CopyRGBA_rev(char* image, const char* buf) {
|
|
|
1591 int mask = is_mask ? 0 : 0xff000000;
|
|
|
1592 /* 色変換を行う */
|
|
|
1593 int len = width * height;
|
|
|
1594 int i;
|
|
|
1595 unsigned char* s = (unsigned char*)buf;
|
|
|
1596 int* d = (int*)image;
|
|
|
1597 for(i=0; i<len; i++) {
|
|
|
1598 *d = (int(s[2])) | (int(s[1])<<8) | (int(s[0])<<16) | (int(s[3])<<24) | mask;
|
|
|
1599 d++; s += 4;
|
|
|
1600 }
|
|
|
1601 return;
|
|
|
1602 }
|
|
|
1603
|
|
|
1604 void GRPCONV::CopyRGBA(char* image, const char* buf) {
|
|
|
1605 if (!is_mask) {
|
|
|
1606 CopyRGB(image, buf);
|
|
|
1607 return;
|
|
|
1608 }
|
|
|
1609 /* 色変換を行う */
|
|
|
1610 int len = width * height;
|
|
|
1611 int i;
|
|
|
1612 int* outbuf = (int*)image;
|
|
|
1613 for(i=0; i<len; i++) {
|
|
|
1614 *outbuf++ = read_little_endian_int(buf);
|
|
|
1615 buf += 4;
|
|
|
1616 }
|
|
|
1617 return;
|
|
|
1618 }
|
|
|
1619 void GRPCONV::CopyRGB(char* image, const char* buf) {
|
|
|
1620 /* 色変換を行う */
|
|
|
1621 int len = width * height;
|
|
|
1622 int i;
|
|
|
1623 unsigned char* s = (unsigned char*)buf;
|
|
|
1624 int* d = (int*)image;
|
|
|
1625 for(i=0; i<len; i++) {
|
|
|
1626 *d = (int(s[0])) | (int(s[1])<<8) | (int(s[2])<<16) | 0xff000000;
|
|
|
1627 d++; s+=3;
|
|
|
1628 }
|
|
|
1629 return;
|
|
|
1630 }
|
|
|
1631
|
|
|
1632 #if HAVE_LIBPNG
|
|
|
1633 PNGCONV::PNGCONV(const char* _inbuf, int _inlen, const char* _filename) {
|
|
|
1634 int w,h,type;
|
|
|
1635 png_structp png_ptr = 0;
|
|
|
1636 png_infop info_ptr = 0;
|
|
|
1637 png_infop end_info = 0;
|
|
|
1638
|
|
|
1639 png_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING, 0, 0, 0);
|
|
|
1640 if (!png_ptr) return;
|
|
|
1641
|
|
|
1642 info_ptr = png_create_info_struct(png_ptr);
|
|
|
1643 if (!info_ptr) goto err;
|
|
|
1644
|
|
|
1645 end_info = png_create_info_struct(png_ptr);
|
|
|
1646 if (!end_info) goto err;
|
|
|
1647
|
|
|
1648 if (setjmp(png_jmpbuf(png_ptr))) {
|
|
|
1649 /* error occured !! */
|
|
|
1650 goto err;
|
|
|
1651 }
|
|
|
1652
|
|
|
1653 /* initialize I/O */
|
|
|
1654 png_data = _inbuf;
|
|
|
1655 png_set_read_fn(png_ptr, (png_voidp)this, &png_read);
|
|
|
1656
|
|
|
1657 png_read_info(png_ptr, info_ptr);
|
|
|
1658
|
|
|
1659 w = png_get_image_width(png_ptr, info_ptr);
|
|
|
1660 h = png_get_image_height(png_ptr, info_ptr);
|
|
|
1661 type = png_get_color_type(png_ptr, info_ptr);
|
|
|
1662
|
|
|
1663 if (type == PNG_COLOR_TYPE_GRAY || type == PNG_COLOR_TYPE_GRAY_ALPHA) goto err; // not supported
|
|
|
1664
|
|
|
1665 Init(filename, _inbuf, _inlen, w, h, type == PNG_COLOR_TYPE_RGB_ALPHA ? true : false);
|
|
|
1666
|
|
|
1667 err:
|
|
|
1668 if (png_ptr) {
|
|
|
1669 if (end_info)
|
|
|
1670 png_destroy_read_struct(&png_ptr, &info_ptr,&end_info);
|
|
|
1671 else if (info_ptr)
|
|
|
1672 png_destroy_read_struct(&png_ptr, &info_ptr,(png_infopp)0);
|
|
|
1673 else
|
|
|
1674 png_destroy_read_struct(&png_ptr, (png_infopp) 0,(png_infopp)0);
|
|
|
1675 }
|
|
|
1676 return;
|
|
|
1677 }
|
|
|
1678
|
|
|
1679 bool PNGCONV::Read(char* image) {
|
|
|
1680 if (data == 0) return false;
|
|
|
1681 bool retcode = false;
|
|
|
1682 int bpp = is_mask ? 4 : 3;
|
|
|
1683 int i;
|
|
|
1684 char* buf;
|
|
|
1685 png_bytepp row_pointers = 0;
|
|
|
1686
|
|
|
1687 png_structp png_ptr = 0;
|
|
|
1688 png_infop info_ptr = 0;
|
|
|
1689 png_infop end_info = 0;
|
|
|
1690
|
|
|
1691 png_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING, 0, 0, 0);
|
|
|
1692 if (!png_ptr) goto err;
|
|
|
1693 info_ptr = png_create_info_struct(png_ptr);
|
|
|
1694 if (!info_ptr) goto err;
|
|
|
1695 end_info = png_create_info_struct(png_ptr);
|
|
|
1696 if (!end_info) goto err;
|
|
|
1697
|
|
|
1698 if (setjmp(png_jmpbuf(png_ptr))) {
|
|
|
1699 /* error occured !! */
|
|
|
1700 goto err;
|
|
|
1701 }
|
|
|
1702
|
|
|
1703 buf= new char[width*height*4];
|
|
|
1704 /* initialize I/O */
|
|
|
1705 png_data = data;
|
|
|
1706 png_set_read_fn(png_ptr, (png_voidp)this, &png_read);
|
|
|
1707
|
|
|
1708 row_pointers = (png_bytepp)png_malloc(png_ptr, height*sizeof(png_bytep));
|
|
|
1709 for (i=0; i<height; i++) row_pointers[i] = (png_bytep)(buf + width*bpp*i);
|
|
|
1710 png_set_rows(png_ptr, info_ptr, row_pointers);
|
|
|
1711
|
|
|
1712 png_read_png(png_ptr, info_ptr,
|
|
|
1713 PNG_TRANSFORM_STRIP_16 | PNG_TRANSFORM_EXPAND | PNG_TRANSFORM_PACKING | PNG_TRANSFORM_BGR,0);
|
|
|
1714
|
|
|
1715 if (buf != image) {
|
|
|
1716 CopyRGBA(image, buf);
|
|
|
1717 delete[] buf;
|
|
|
1718 }
|
|
|
1719 png_free(png_ptr, (png_voidp)row_pointers);
|
|
|
1720
|
|
|
1721 retcode = true;
|
|
|
1722 err:
|
|
|
1723 if (png_ptr) {
|
|
|
1724 if (end_info)
|
|
|
1725 png_destroy_read_struct(&png_ptr, &info_ptr,&end_info);
|
|
|
1726 else if (info_ptr)
|
|
|
1727 png_destroy_read_struct(&png_ptr, &info_ptr,(png_infopp)0);
|
|
|
1728 else
|
|
|
1729 png_destroy_read_struct(&png_ptr, (png_infopp) 0,(png_infopp)0);
|
|
|
1730 }
|
|
|
1731 return retcode;
|
|
|
1732 }
|
|
|
1733
|
|
|
1734 void PNGCONV::png_read(png_structp png_ptr, png_bytep d, png_size_t sz) {
|
|
|
1735 PNGCONV* orig = (PNGCONV*)png_get_io_ptr(png_ptr);
|
|
|
1736 memcpy(d, orig->png_data, sz);
|
|
|
1737 orig->png_data += sz;
|
|
|
1738 return;
|
|
|
1739 }
|
|
|
1740 #endif /* HAVE_LIBPNG */
|
|
|
1741
|
|
|
1742 #if HAVE_LIBJPEG
|
|
|
1743 JPEGCONV::JPEGCONV(const char* _inbuf, int _inlen, const char* _filename) {
|
|
|
1744 int w,h,type;
|
|
|
1745 JSAMPARRAY rows, rows_orig; int i;
|
|
|
1746 char* buf = 0;
|
|
|
1747
|
|
|
1748 struct jpeg_decompress_struct cinfo;
|
|
|
1749 struct jpeg_error_mgr jerr;
|
|
|
1750 cinfo.err = jpeg_std_error(&jerr);
|
|
|
1751 jpeg_create_decompress(&cinfo);
|
|
|
1752 cinfo.src = new jpeg_source_mgr;
|
|
|
1753 SetupSrc(&cinfo, _inbuf, _inlen);
|
|
|
1754
|
|
|
1755 if (jpeg_read_header(&cinfo, TRUE) == JPEG_HEADER_OK) {
|
|
|
1756 Init(filename, _inbuf, _inlen, cinfo.image_width, cinfo.image_height, false);
|
|
|
1757 }
|
|
|
1758 delete cinfo.src;
|
|
|
1759 cinfo.src = 0;
|
|
|
1760 jpeg_destroy_decompress(&cinfo);
|
|
|
1761 return;
|
|
|
1762 }
|
|
|
1763
|
|
|
1764 bool JPEGCONV::Read(char* image) {
|
|
|
1765 if (data == 0) return false;
|
|
|
1766 bool retcode = false;
|
|
|
1767 JSAMPARRAY rows, rows_orig; int i;
|
|
|
1768 char* buf = 0;
|
|
|
1769
|
|
|
1770 struct jpeg_decompress_struct cinfo;
|
|
|
1771 struct jpeg_error_mgr jerr;
|
|
|
1772 cinfo.err = jpeg_std_error(&jerr);
|
|
|
1773 jpeg_create_decompress(&cinfo);
|
|
|
1774 cinfo.src = new jpeg_source_mgr;
|
|
|
1775 SetupSrc(&cinfo, data, datalen);
|
|
|
1776
|
|
|
1777 if (jpeg_read_header(&cinfo, TRUE) != JPEG_HEADER_OK) goto err;
|
|
|
1778
|
|
|
1779 cinfo.out_color_space = JCS_RGB;
|
|
|
1780
|
|
|
1781 jpeg_start_decompress(&cinfo);
|
|
|
1782
|
|
|
1783 rows = new JSAMPROW[height];
|
|
|
1784 rows_orig = rows;
|
|
|
1785 buf = new char[width*height*3];
|
|
|
1786 for (i=0; i<height; i++) rows[i] = (JSAMPROW)(buf+width*3*i);
|
|
|
1787
|
|
|
1788 for (i=0; i<height; ) {
|
|
|
1789 int cnt = jpeg_read_scanlines(&cinfo, rows, height-i);
|
|
|
1790 rows += cnt;
|
|
|
1791 i += cnt;
|
|
|
1792 }
|
|
|
1793 delete[] rows_orig;
|
|
|
1794 CopyRGBA_rev(image, buf);
|
|
|
1795 delete[] buf;
|
|
|
1796
|
|
|
1797 jpeg_finish_decompress(&cinfo);
|
|
|
1798 retcode = true;
|
|
|
1799 err:
|
|
|
1800 delete cinfo.src;
|
|
|
1801 cinfo.src = 0;
|
|
|
1802 jpeg_destroy_decompress(&cinfo);
|
|
|
1803 return retcode;
|
|
|
1804 }
|
|
|
1805
|
|
|
1806 void JPEGCONV::init_source(j_decompress_ptr cinfo) {
|
|
|
1807 }
|
|
|
1808 boolean JPEGCONV::fill_input_buffer(j_decompress_ptr cinfo) {
|
|
|
1809 static char dummy[1024];
|
|
|
1810 memset(dummy, 0, 1024);
|
|
|
1811 cinfo->src->next_input_byte = (const JOCTET*)dummy;
|
|
|
1812 cinfo->src->bytes_in_buffer = 1024;
|
|
|
1813 fprintf(stderr,"JPEGCONV::fill_input_buffer: warning corrupted jpeg stream\n");
|
|
|
1814 return TRUE;
|
|
|
1815 }
|
|
|
1816 void JPEGCONV::skip_input_data(j_decompress_ptr cinfo, long num_bytes) {
|
|
|
1817 if (cinfo->src->bytes_in_buffer > num_bytes) {
|
|
|
1818 cinfo->src->next_input_byte += num_bytes;
|
|
|
1819 cinfo->src->bytes_in_buffer -= num_bytes;
|
|
|
1820 }
|
|
|
1821 }
|
|
|
1822 boolean JPEGCONV::resync_to_restart(j_decompress_ptr cinfo, int desired) {
|
|
|
1823 return jpeg_resync_to_restart(cinfo, desired);
|
|
|
1824 }
|
|
|
1825 void JPEGCONV::term_source(j_decompress_ptr cinf) {
|
|
|
1826 }
|
|
|
1827
|
|
|
1828 void JPEGCONV::SetupSrc(struct jpeg_decompress_struct* cinfo, const char* data, int size) {
|
|
|
1829 cinfo->src->next_input_byte = (const JOCTET*) data;
|
|
|
1830 cinfo->src->bytes_in_buffer = size;
|
|
|
1831 cinfo->src->init_source = init_source;
|
|
|
1832 cinfo->src->fill_input_buffer = fill_input_buffer;
|
|
|
1833 cinfo->src->skip_input_data = skip_input_data;
|
|
|
1834 cinfo->src->resync_to_restart = resync_to_restart;
|
|
|
1835 cinfo->src->term_source = term_source;
|
|
|
1836 }
|
|
|
1837 #endif /* HAVE_LIBJPEG */
|
|
|
1838 BMPCONV::BMPCONV(const char* _inbuf, int _inlen, const char* _filename) {
|
|
|
1839 /* データから情報読み込み */
|
|
|
1840 int w = read_little_endian_int(_inbuf + 0x12);
|
|
|
1841 int h = read_little_endian_int(_inbuf + 0x16);
|
|
|
1842 if (h < 0) h = -h;
|
|
|
1843 int bpp = read_little_endian_short(_inbuf + 0x1c);
|
|
|
1844 int comp = read_little_endian_int(_inbuf + 0x1e);
|
|
|
1845 Init(filename, _inbuf, _inlen, w, h, bpp==32 ? true : false);
|
|
|
1846 return;
|
|
|
1847 }
|
|
|
1848
|
|
|
1849 bool BMPCONV::Read(char* image) {
|
|
|
1850 if (data == 0) return false;
|
|
|
1851
|
|
|
1852 /* マスクのチェック */
|
|
|
1853 int bpp = read_little_endian_short(data+0x1c);
|
|
|
1854 int h = read_little_endian_int(data + 0x16);
|
|
|
1855 int dsz = read_little_endian_int(data + 0x22);
|
|
|
1856 bpp /= 8;
|
|
|
1857
|
|
|
1858 int bpl = dsz / height;
|
|
|
1859 if (bpl == 0) bpl = bpp*width;
|
|
|
1860 bpl = bpp * width;
|
|
|
1861 bpl = (bpl+3) & (~3);
|
|
|
1862
|
|
|
1863
|
|
|
1864 int i;
|
|
|
1865 char* buf = new char[width*height*bpp+1024];
|
|
|
1866 const char* src = data + 0x36;
|
|
|
1867 char* dest = buf;
|
|
|
1868 if (h < 0) {
|
|
|
1869 for (i=0; i<height; i++) {
|
|
|
1870 memcpy(dest+i*width*bpp, src+i*bpl, width*bpp);
|
|
|
1871 }
|
|
|
1872 } else {
|
|
|
1873 for (i=0; i<height; i++) {
|
|
|
1874 memcpy(dest+i*width*bpp, src+(height-i-1)*bpl, width*bpp);
|
|
|
1875 }
|
|
|
1876 }
|
|
|
1877 if (bpp == 3) CopyRGB(image, buf);
|
|
|
1878 else /* bpp == 4 */ CopyRGBA(image, buf);
|
|
|
1879 delete[] buf;
|
|
|
1880 return true;
|
|
|
1881 }
|
|
|
1882
|
