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