?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
fnt: Improved error handling, etc.
[deark.git] / modules / atari-img.c
blob0f2c024ae7f3830f4bbe6f50570d0de85e9f52ef
1 // This file is part of Deark.
2 // Copyright (C) 2016 Jason Summers
3 // See the file COPYING for terms of use.
4
5 #include <deark-config.h>
6 #include <deark-private.h>
7 #include <deark-fmtutil.h>
8 DE_DECLARE_MODULE(de_module_degas);
9 DE_DECLARE_MODULE(de_module_prismpaint);
10 DE_DECLARE_MODULE(de_module_ftc);
11 DE_DECLARE_MODULE(de_module_eggpaint);
12 DE_DECLARE_MODULE(de_module_indypaint);
13 DE_DECLARE_MODULE(de_module_godpaint);
14 DE_DECLARE_MODULE(de_module_tinystuff);
15 DE_DECLARE_MODULE(de_module_doodle);
16 DE_DECLARE_MODULE(de_module_neochrome);
17 DE_DECLARE_MODULE(de_module_neochrome_ani);
18 DE_DECLARE_MODULE(de_module_fpaint_pi4);
19 DE_DECLARE_MODULE(de_module_fpaint_pi9);
20 DE_DECLARE_MODULE(de_module_atari_pi7);
21 DE_DECLARE_MODULE(de_module_falcon_xga);
22 DE_DECLARE_MODULE(de_module_coke);
23 DE_DECLARE_MODULE(de_module_animatic);
24 DE_DECLARE_MODULE(de_module_videomaster);
25
26 static void fix_dark_pal(deark *c, struct atari_img_decode_data *adata);
27
28 static void help_respectpal(deark *c)
29 {
30 de_msg(c, "-opt atari:respectpal : Don't ignore a seemingly bad 2-color palette");
31 }
32
33 // **************************************************************************
34 // DEGAS / DEGAS Elite images
35 // **************************************************************************
36
37 typedef struct degasctx_struct {
38 unsigned int compression_code;
39 int degas_elite_flag;
40 u32 pal[16];
41 } degasctx;
42
43 static void do_degas_anim_fields(deark *c, degasctx *d, i64 pos)
44 {
45 i64 i;
46 i64 n;
47
48 for(i=0; i<4; i++) {
49 n = de_getu16be(pos + 2*i);
50 de_dbg2(c, "left_color_anim[%d] = %d", (int)i, (int)n);
51 }
52 for(i=0; i<4; i++) {
53 n = de_getu16be(pos + 8 + 2*i);
54 de_dbg2(c, "right_color_anim[%d] = %d", (int)i, (int)n);
55 }
56 for(i=0; i<4; i++) {
57 n = de_getu16be(pos + 16 + 2*i);
58 de_dbg2(c, "channel_direction[%d] = %d", (int)i, (int)n);
59 }
60 for(i=0; i<4; i++) {
61 n = de_getu16be(pos + 24 + 2*i);
62 de_dbg2(c, "channel_delay_code[%d] = %d", (int)i, (int)n);
63 }
64
65 // TODO: Can we determine if palette animation is actually used,
66 // and only show the warning if it is?
67 //de_warn(c, "This image may use palette cycling animation, which is not supported.");
68 }
69
70 // Try to figure out if this is a DEGAS Elite file (as opposed to original DEGAS).
71 static int is_degas_elite(deark *c, degasctx *d)
72 {
73 i64 n;
74 i64 x;
75 i64 pos;
76 int all_zero = 1;
77
78 if(d->compression_code) return 1; // Only DEGAS Elite supports compression.
79 if(c->infile->len < 32066) return 0;
80
81 // Test if the animation segment seems to have valid values, to try to distinguish
82 // it from meaningless padding. (This is overkill.)
83 pos = 32034;
84 for(n=0; n<8; n++) {
85 // The first 8 fields are "color numbers".
86 // Guessing that they should be 0-15.
87 x = de_getu16be(pos+n*2);
88 if(x>0x0f) return 0;
89 if(x) all_zero = 0;
90 }
91 pos += 8*2;
92 for(n=0; n<4; n++) {
93 // The next 4 fields (channel direction) should be 0, 1, or 2.
94 x = de_getu16be(pos+n*2);
95 if(x>2) return 0;
96 if(x) all_zero = 0;
97 }
98 pos += 4*2;
99 for(n=0; n<4; n++) {
100 // The next 4 fields (delay) must be from 0 to 128.
101 x = de_getu16be(pos+n*2);
102 if(x>128) return 0;
103 if(x) all_zero = 0;
104 }
105
106 if(all_zero && c->infile->len>32068) {
107 // If every field was 0, and the file size doesn't suggest Elite,
108 // just assume it's not valid.
109 return 0;
110 }
111
112 return 1;
113 }
114
115 static void de_run_degas(deark *c, de_module_params *mparams)
116 {
117 degasctx *d = NULL;
118 struct atari_img_decode_data *adata = NULL;
119 de_finfo *fi = NULL;
120 i64 pos;
121 unsigned int format_code, resolution_code;
122 int is_grayscale;
123 i64 cmpr_bytes_consumed = 0;
124
125 d = de_malloc(c, sizeof(degasctx));
126 adata = de_malloc(c, sizeof(struct atari_img_decode_data));
127
128 adata->pal = d->pal;
129
130 pos = 0;
131 format_code = (unsigned int)de_getu16be(pos);
132 de_dbg(c, "format code: 0x%04x", format_code);
133 resolution_code = format_code & 0x0003;
134 d->compression_code = (format_code & 0x8000)>>15;
135 de_dbg_indent(c, 1);
136 de_dbg(c, "resolution code: %u", resolution_code);
137 de_dbg(c, "compression code: %u", d->compression_code);
138 de_dbg_indent(c, -1);
139 pos += 2;
140
141 switch(resolution_code) {
142 case 0:
143 adata->bpp = 4;
144 adata->w = 320;
145 adata->h = 200;
146 break;
147 case 1:
148 adata->bpp = 2;
149 adata->w = 640;
150 adata->h = 200;
151 break;
152 case 2:
153 adata->bpp = 1;
154 adata->w = 640;
155 adata->h = 400;
156 break;
157 default:
158 de_dbg(c, "Invalid or unsupported resolution (%u)", resolution_code);
159 goto done;
160 }
161 adata->ncolors = de_pow2(adata->bpp);
162
163 de_dbg(c, "dimensions: %d"DE_CHAR_TIMES"%d, colors: %d", (int)adata->w, (int)adata->h, (int)adata->ncolors);
164
165 d->degas_elite_flag = is_degas_elite(c, d);
166 de_declare_fmtf(c, "DEGAS%s %d-color %scompressed",
167 d->degas_elite_flag?" Elite":"",
168 (int)adata->ncolors,
169 d->compression_code?"":"un");
170
171 fmtutil_read_atari_palette(c, c->infile, pos, adata->pal, 16, adata->ncolors, 0);
172 pos += 2*16;
173 fix_dark_pal(c, adata);
174
175 if(d->compression_code) {
176 adata->was_compressed = 1;
177 adata->unc_pixels = dbuf_create_membuf(c, 32000, 1);
178 dbuf_enable_wbuffer(adata->unc_pixels);
179
180 if(!fmtutil_decompress_packbits(c->infile, pos, c->infile->len-pos, adata->unc_pixels, &cmpr_bytes_consumed))
181 goto done;
182 dbuf_flush(adata->unc_pixels);
183
184 de_dbg(c, "Compressed bytes found: %d", (int)cmpr_bytes_consumed);
185 pos += cmpr_bytes_consumed;
186 }
187 else {
188 i64 avail_bytes = 32000;
189 if(pos+32000 > c->infile->len) {
190 avail_bytes = c->infile->len - pos;
191 de_warn(c, "Unexpected end of file (expected 32000 bytes, got %d)", (int)avail_bytes);
192 }
193 adata->unc_pixels = dbuf_open_input_subfile(c->infile, pos, avail_bytes);
194 pos += avail_bytes;
195 }
196
197 if(pos + 32 == c->infile->len) {
198 do_degas_anim_fields(c, d, pos);
199 }
200
201 is_grayscale = de_is_grayscale_palette(adata->pal, adata->ncolors);
202
203 adata->img = de_bitmap_create(c, adata->w, adata->h, is_grayscale?1:3);
204
205 fi = de_finfo_create(c);
206 fmtutil_atari_set_standard_density(c, adata, fi);
207
208 fmtutil_atari_decode_image(c, adata);
209
210 de_bitmap_write_to_file_finfo(adata->img, fi, 0);
211
212 done:
213 if(adata) {
214 dbuf_close(adata->unc_pixels);
215 de_bitmap_destroy(adata->img);
216 de_free(c, adata);
217 }
218 de_finfo_destroy(c, fi);
219 de_free(c, d);
220 }
221
222 static int de_identify_degas(deark *c)
223 {
224 static const char *exts[6] = {"pi1", "pi2", "pi3", "pc1", "pc2", "pc3" };
225 i64 i;
226 int flag;
227 i64 sig;
228
229 flag = 0;
230 for(i=0; i<6; i++) {
231 if(de_input_file_has_ext(c, exts[i])) {
232 flag = 1;
233 break;
234 }
235 }
236 if(!flag) return 0;
237
238 sig = de_getu16be(0);
239 if(sig==0x0000 || sig==0x0001 || sig==0x0002) {
240 if(c->infile->len==32034) return 100; // DEGAS
241 if(c->infile->len==32066) return 100; // DEGAS Elite
242 if(c->infile->len==32128) return 40; // Could be padded to a multiple of 128 bytes
243 if(c->infile->len>16000) return 10;
244 }
245 else if(sig==0x8000 || sig==0x8001 || sig==0x8002) {
246 return 60;
247 }
248
249 return 0;
250 }
251
252 static void de_help_degas(deark *c)
253 {
254 fmtutil_atari_help_palbits(c);
255 help_respectpal(c);
256 }
257
258 void de_module_degas(deark *c, struct deark_module_info *mi)
259 {
260 mi->id = "degas";
261 mi->desc = "Atari DEGAS or DEGAS Elite image";
262 mi->run_fn = de_run_degas;
263 mi->identify_fn = de_identify_degas;
264 mi->help_fn = de_help_degas;
265 }
266
267 // **************************************************************************
268 // Atari Prism Paint (.pnt)
269 // **************************************************************************
270
271 typedef struct prismctx_struct {
272 i64 pal_size;
273 UI compression_code;
274 i64 pic_data_size;
275 u32 pal[256];
276 } prismctx;
277
278 // A color value of N does not necessarily refer to Nth color in the palette.
279 // Some of them are mixed up. Apparently this is called "VDI order".
280 // Reference: http://toshyp.atari.org/en/VDI_fundamentals.html
281 static unsigned int map_vdi_pal(i64 bpp, unsigned int v)
282 {
283 if(bpp==1) return v;
284 switch(v) {
285 case 1: return 2;
286 case 2: return 3;
287 case 3: return bpp>2 ? 6 : 1;
288 case 5: return 7;
289 case 6: return 5;
290 case 7: return 8;
291 case 8: return 9;
292 case 9: return 10;
293 case 10: return 11;
294 case 11: return 14;
295 case 13: return 15;
296 case 14: return 13;
297 case 15: return bpp==8 ? 255 : 1;
298 case 255: return 1;
299 }
300 return v;
301 }
302
303 static void do_prism_read_palette(deark *c, prismctx *d, struct atari_img_decode_data *adata)
304 {
305 i64 i;
306 i64 r1, g1, b1;
307 u8 r, g, b;
308 u32 pal1[256];
309 u32 clr;
310 i64 num_entries_to_read;
311 char tmps[32];
312
313 de_zeromem(pal1, sizeof(pal1));
314 num_entries_to_read = de_min_int(d->pal_size, 256);
315
316 for(i=0; i<num_entries_to_read; i++) {
317 r1 = de_getu16be(128+6*i+0);
318 g1 = de_getu16be(128+6*i+2);
319 b1 = de_getu16be(128+6*i+4);
320 r = de_scale_1000_to_255(r1);
321 g = de_scale_1000_to_255(g1);
322 b = de_scale_1000_to_255(b1);
323 clr = DE_MAKE_RGB(r,g,b);
324 de_snprintf(tmps, sizeof(tmps), "(%4d,%4d,%4d) "DE_CHAR_RIGHTARROW" ",
325 (int)r1, (int)g1, (int)b1);
326 de_dbg_pal_entry2(c, i, clr, tmps, NULL, NULL);
327 pal1[i] = clr;
328 }
329
330 for(i=0; i<num_entries_to_read; i++) {
331 d->pal[i] = pal1[map_vdi_pal(adata->bpp, (unsigned int)i)];
332 }
333 }
334
335 static void de_run_prismpaint(deark *c, de_module_params *mparams)
336 {
337 prismctx *d = NULL;
338 i64 pixels_start;
339 struct atari_img_decode_data *adata = NULL;
340
341 d = de_malloc(c, sizeof(prismctx));
342
343 adata = de_malloc(c, sizeof(struct atari_img_decode_data));
344
345 adata->pal = d->pal;
346 d->pal_size = de_getu16be(6);
347 de_dbg(c, "pal_size: %d", (int)d->pal_size);
348 adata->w = de_getu16be(8);
349 adata->h = de_getu16be(10);
350 de_dbg_dimensions(c, adata->w, adata->h);
351 if(!de_good_image_dimensions(c, adata->w, adata->h)) goto done;
352
353 adata->bpp = de_getu16be(12);
354 de_dbg(c, "bits/pixel: %d", (int)adata->bpp);
355 d->compression_code = (UI)de_getu16be(14);
356 de_dbg(c, "compression: %u", d->compression_code);
357
358 d->pic_data_size = de_getu32be(16);
359 de_dbg(c, "reported (uncompressed) picture data size: %"I64_FMT, d->pic_data_size);
360
361 do_prism_read_palette(c, d, adata);
362
363 if(adata->bpp!=1 && adata->bpp!=2 && adata->bpp!=4
364 && adata->bpp!=8 && adata->bpp!=16)
365 {
366 de_err(c, "Unsupported bits/pixel: %d", (int)adata->bpp);
367 goto done;
368 }
369 if(d->compression_code!=0 && d->compression_code!=1) {
370 de_err(c, "Unsupported compression: %u", d->compression_code);
371 goto done;
372 }
373 if(adata->bpp==16 && d->compression_code!=0) {
374 de_warn(c, "Compressed 16-bit image support is untested, and may not work.");
375 }
376
377 pixels_start = 128 + 2*3*d->pal_size;
378 de_dbg(c, "pixel data starts at %"I64_FMT, pixels_start);
379 if(pixels_start >= c->infile->len) goto done;
380
381 if(d->compression_code==0) {
382 adata->unc_pixels = dbuf_open_input_subfile(c->infile, pixels_start,
383 c->infile->len - pixels_start);
384 }
385 else {
386 adata->was_compressed = 1;
387 // TODO: Calculate the initial size more accurately.
388 adata->unc_pixels = dbuf_create_membuf(c, adata->w*adata->h, 0);
389 //dbuf_set_max_length(unc_pixels, ...);
390 dbuf_enable_wbuffer(adata->unc_pixels);
391
392 fmtutil_decompress_packbits(c->infile, pixels_start, c->infile->len - pixels_start,
393 adata->unc_pixels, NULL);
394 dbuf_flush(adata->unc_pixels);
395 de_dbg(c, "decompressed to %"I64_FMT" bytes", adata->unc_pixels->len);
396 }
397
398 adata->img = de_bitmap_create(c, adata->w, adata->h, 3);
399 fmtutil_atari_decode_image(c, adata);
400 de_bitmap_write_to_file(adata->img, NULL, 0);
401
402 done:
403 if(adata) {
404 dbuf_close(adata->unc_pixels);
405 de_bitmap_destroy(adata->img);
406 de_free(c, adata);
407 }
408 de_free(c, d);
409 }
410
411 static int de_identify_prismpaint(deark *c)
412 {
413 if(!dbuf_memcmp(c->infile, 0, "PNT\x00", 4))
414 return 100;
415 return 0;
416 }
417
418 void de_module_prismpaint(deark *c, struct deark_module_info *mi)
419 {
420 mi->id = "prismpaint";
421 mi->desc = "Atari Prism Paint .PNT, a.k.a. TruePaint .TPI";
422 mi->run_fn = de_run_prismpaint;
423 mi->identify_fn = de_identify_prismpaint;
424 }
425
426 // **************************************************************************
427 // Atari Falcon True Color .FTC
428 // **************************************************************************
429
430 static void de_run_ftc(deark *c, de_module_params *mparams)
431 {
432 struct atari_img_decode_data *adata = NULL;
433 de_finfo *fi = NULL;
434
435 adata = de_malloc(c, sizeof(struct atari_img_decode_data));
436 adata->bpp = 16;
437 adata->w = 384;
438 adata->h = 240;
439 adata->unc_pixels = c->infile;
440 adata->img = de_bitmap_create(c, adata->w, adata->h, 3);
441 fi = de_finfo_create(c);
442 fi->density.code = DE_DENSITY_UNK_UNITS;
443 fi->density.xdens = 288;
444 fi->density.ydens = 240;
445 fmtutil_atari_decode_image(c, adata);
446 de_bitmap_write_to_file_finfo(adata->img, fi, 0);
447 de_bitmap_destroy(adata->img);
448 de_finfo_destroy(c, fi);
449 de_free(c, adata);
450 }
451
452 static int de_identify_ftc(deark *c)
453 {
454 if(c->infile->len != 184320) return 0;
455 if(!de_input_file_has_ext(c, "ftc")) return 0;
456 return 60;
457 }
458
459 void de_module_ftc(deark *c, struct deark_module_info *mi)
460 {
461 mi->id = "ftc";
462 mi->desc = "Atari Falcon True Color .FTC";
463 mi->run_fn = de_run_ftc;
464 mi->identify_fn = de_identify_ftc;
465 }
466
467 // **************************************************************************
468 // Atari Falcon EggPaint .TRP
469 // **************************************************************************
470
471 static void de_run_eggpaint(deark *c, de_module_params *mparams)
472 {
473 struct atari_img_decode_data *adata = NULL;
474
475 adata = de_malloc(c, sizeof(struct atari_img_decode_data));
476
477 if(!dbuf_memcmp(c->infile, 0, "tru?", 4)) {
478 de_declare_fmt(c, "Spooky Sprites");
479 }
480 else {
481 de_declare_fmt(c, "EggPaint");
482 }
483
484 adata->bpp = 16;
485 adata->w = de_getu16be(4);
486 adata->h = de_getu16be(6);
487 de_dbg_dimensions(c, adata->w, adata->h);
488 adata->unc_pixels = dbuf_open_input_subfile(c->infile, 8, c->infile->len-8);
489 adata->img = de_bitmap_create(c, adata->w, adata->h, 3);
490 fmtutil_atari_decode_image(c, adata);
491 de_bitmap_write_to_file(adata->img, NULL, 0);
492
493 dbuf_close(adata->unc_pixels);
494 de_bitmap_destroy(adata->img);
495 de_free(c, adata);
496 }
497
498 static int de_identify_eggpaint(deark *c)
499 {
500 if(!dbuf_memcmp(c->infile, 0, "TRUP", 4)) {
501 return 80;
502 }
503 if(!dbuf_memcmp(c->infile, 0, "tru?", 4)) {
504 return 100;
505 }
506 return 0;
507 }
508
509 void de_module_eggpaint(deark *c, struct deark_module_info *mi)
510 {
511 mi->id = "eggpaint";
512 mi->desc = "Atari EggPaint .TRP";
513 mi->run_fn = de_run_eggpaint;
514 mi->identify_fn = de_identify_eggpaint;
515 }
516
517 // **************************************************************************
518 // Atari Falcon IndyPaint .TRU
519 // **************************************************************************
520
521 static void de_run_indypaint(deark *c, de_module_params *mparams)
522 {
523 struct atari_img_decode_data *adata = NULL;
524
525 adata = de_malloc(c, sizeof(struct atari_img_decode_data));
526 adata->bpp = 16;
527 adata->w = de_getu16be(4);
528 adata->h = de_getu16be(6);
529 de_dbg_dimensions(c, adata->w, adata->h);
530 adata->unc_pixels = dbuf_open_input_subfile(c->infile, 256, c->infile->len-256);
531 adata->img = de_bitmap_create(c, adata->w, adata->h, 3);
532 fmtutil_atari_decode_image(c, adata);
533 de_bitmap_write_to_file(adata->img, NULL, 0);
534
535 dbuf_close(adata->unc_pixels);
536 de_bitmap_destroy(adata->img);
537 de_free(c, adata);
538 }
539
540 static int de_identify_indypaint(deark *c)
541 {
542 if(!dbuf_memcmp(c->infile, 0, "Indy", 4)) {
543 return 70;
544 }
545 return 0;
546 }
547
548 void de_module_indypaint(deark *c, struct deark_module_info *mi)
549 {
550 mi->id = "indypaint";
551 mi->desc = "Atari IndyPaint .TRU";
552 mi->run_fn = de_run_indypaint;
553 mi->identify_fn = de_identify_indypaint;
554 }
555
556 // **************************************************************************
557 // Atari Falcon GodPaint .GOD
558 // **************************************************************************
559
560 static void de_run_godpaint(deark *c, de_module_params *mparams)
561 {
562 struct atari_img_decode_data *adata = NULL;
563
564 adata = de_malloc(c, sizeof(struct atari_img_decode_data));
565 adata->bpp = 16;
566 adata->w = de_getu16be(2);
567 adata->h = de_getu16be(4);
568 de_dbg_dimensions(c, adata->w, adata->h);
569 adata->unc_pixels = dbuf_open_input_subfile(c->infile, 6, c->infile->len-6);
570 adata->img = de_bitmap_create(c, adata->w, adata->h, 3);
571 fmtutil_atari_decode_image(c, adata);
572 de_bitmap_write_to_file(adata->img, NULL, 0);
573
574 dbuf_close(adata->unc_pixels);
575 de_bitmap_destroy(adata->img);
576 de_free(c, adata);
577 }
578
579 static int de_identify_godpaint(deark *c)
580 {
581 i64 sig;
582
583 sig = de_getu16be(0);
584 if(sig!=0x4734 && sig!=0x0400) return 0;
585 if(de_input_file_has_ext(c, "god")) return 100;
586 if(sig==0x4734) return 5;
587 return 0;
588 }
589
590 void de_module_godpaint(deark *c, struct deark_module_info *mi)
591 {
592 mi->id = "godpaint";
593 mi->desc = "Atari Falcon GodPaint";
594 mi->run_fn = de_run_godpaint;
595 mi->identify_fn = de_identify_godpaint;
596 }
597
598 // **************************************************************************
599 // Tiny Stuff
600 // **************************************************************************
601
602 typedef struct tinyctx_struct {
603 u8 res_code;
604 i64 num_control_bytes;
605 i64 num_data_words;
606 i64 data_words_nbytes;
607 u32 pal[16];
608
609 // Decompression params:
610 i64 numstripes;
611 i64 numscans;
612 i64 dst_rowspan;
613
614 // Decompression state:
615 int stopflag;
616 i64 ypos;
617 i64 stripe;
618 i64 scan;
619 i64 column;
620 i64 dcmpr_word_count;
621 } tinyctx;
622
623 static void tiny_setword(deark *c, tinyctx *d, struct atari_img_decode_data *adata, const u8 *wordbuf)
624 {
625 i64 dstpos;
626
627 // As each word is emitted from the decompressor, we store it in the unc_pixels buffer
628 // in a particular location. The location is chosen so as to make the pixel data more
629 // contiguous, but (for 2bpp and 4bpp images) more work will still have to be done when
630 // the image is generated.
631
632 if(d->stopflag) return;
633 d->dcmpr_word_count++;
634 dstpos = d->stripe * 8 + d->column*2 + (d->ypos * d->numscans + d->scan)*d->dst_rowspan;
635 dbuf_write_at(adata->unc_pixels, dstpos, wordbuf, 2);
636 d->ypos++;
637 if(d->ypos >= 200) {
638 d->ypos = 0;
639 d->stripe++;
640 if(d->stripe >= d->numstripes) {
641 d->stripe = 0;
642 d->scan++;
643 if(d->scan >= d->numscans) {
644 d->scan = 0;
645 d->column++;
646 if(d->column >= 4) {
647 d->stopflag = 1;
648 return;
649 }
650 }
651 }
652 }
653 }
654
655 // Uncompress to adata->unc_pixels.
656 static int tiny_uncompress(deark *c, tinyctx *d, struct atari_img_decode_data *adata, i64 pos)
657 {
658 u8 *control_bytes = NULL;
659 i64 k;
660 i64 count;
661 i64 cpos;
662 u8 ctrl;
663 u8 wordbuf[2];
664
665 if(adata->bpp==1) {
666 d->numscans = 2;
667 d->numstripes = 10;
668 d->dst_rowspan = 80;
669 }
670 else {
671 d->numscans = 1;
672 d->numstripes = 20;
673 d->dst_rowspan = 160;
674 }
675
676 de_dbg(c, "RLE control bytes at %"I64_FMT, pos);
677 control_bytes = de_malloc(c, d->num_control_bytes +2);
678 de_read(control_bytes, pos, d->num_control_bytes);
679 pos += d->num_control_bytes;
680
681 de_dbg(c, "RLE data words at %"I64_FMT, pos);
682
683 cpos = 0;
684
685 d->stopflag = 0;
686 d->scan = 0;
687 d->ypos = 0;
688 d->column = 0;
689 d->stripe = 0;
690 d->dcmpr_word_count = 0;
691
692 while(1) {
693 if(d->stopflag) break;
694 if(cpos >= d->num_control_bytes) break;
695 ctrl = control_bytes[cpos++];
696
697 if(ctrl >= 128) { // Uncompressed run, count encoded in control byte
698 count = 256 - (i64)ctrl;
699 for(k=0; k<count; k++) {
700 dbuf_read(c->infile, wordbuf, pos, 2);
701 pos += 2;
702 tiny_setword(c, d, adata, wordbuf);
703 }
704 }
705 else if(ctrl == 0) { // RLE, 16-bit count in next 2 control bytes
706 count = de_getu16be_direct(&control_bytes[cpos]);
707 cpos += 2;
708 dbuf_read(c->infile, wordbuf, pos, 2);
709 pos += 2;
710 for(k=0; k<count; k++) {
711 tiny_setword(c, d, adata, wordbuf);
712 }
713 }
714 else if(ctrl == 1) { // Uncompressed run, 16-bit count in next 2 control bytes
715 count = de_getu16be_direct(&control_bytes[cpos]);
716 cpos += 2;
717
718 for(k=0; k<count; k++) {
719 dbuf_read(c->infile, wordbuf, pos, 2);
720 pos += 2;
721 tiny_setword(c, d, adata, wordbuf);
722 }
723 }
724 else { // RLE, count encoded in control byte
725 count = (i64)ctrl;
726 dbuf_read(c->infile, wordbuf, pos, 2);
727 pos += 2;
728 for(k=0; k<count; k++) {
729 tiny_setword(c, d, adata, wordbuf);
730 }
731 }
732 }
733
734 de_dbg(c, "decompressed words: %"I64_FMT, d->dcmpr_word_count);
735 if(d->dcmpr_word_count<16000) {
736 de_warn(c, "Expected 16000 decompressed words, got %"I64_FMT, d->dcmpr_word_count);
737 }
738
739 de_free(c, control_bytes);
740 return 1;
741 }
742
743 static void do_tinystuff_1bpp(deark *c, tinyctx *d, struct atari_img_decode_data *adata)
744 {
745 de_convert_image_paletted(adata->unc_pixels, 0, 1, d->dst_rowspan, adata->pal,
746 adata->img, 0);
747 }
748
749 static void do_tinystuff_2or4bpp(deark *c, tinyctx *d, struct atari_img_decode_data *adata)
750 {
751 i64 x, y;
752 i64 pos = 0;
753 i64 width;
754 UI bpp;
755
756 bpp = (UI)adata->bpp;
757 if(bpp!=2 && bpp!=4) return;
758
759 if(bpp==2) width = 640;
760 else width = 320;
761
762 for(y=0; y<200; y++) {
763 for(x=0; x<width; x+=16) {
764 UI n[4];
765 UI b_idx;
766 UI k;
767
768 // 2bpp: Every 2 words (4 bytes; 32 bits) makes 16 pixels
769 // 4bpp: Every 4 words (8 bytes; 64 bits) makes 16 pixels
770 for(b_idx=0; b_idx<bpp; b_idx++) {
771 n[b_idx] = (UI)dbuf_getu16be_p(adata->unc_pixels, &pos);
772 }
773
774 for(k=0; k<16; k++) {
775 UI v = 0;
776
777 for(b_idx=0; b_idx<bpp; b_idx++) {
778 if(n[b_idx]&(1U<<(15-k))) v += (1U<<b_idx);
779 }
780 de_bitmap_setpixel_rgb(adata->img, x+(i64)k, y, adata->pal[v]);
781 }
782 }
783 }
784 }
785
786 static void do_tinystuff_image(deark *c, tinyctx *d, struct atari_img_decode_data *adata)
787 {
788 switch(adata->bpp) {
789 case 1:
790 do_tinystuff_1bpp(c, d, adata);
791 break;
792 case 2:
793 case 4:
794 do_tinystuff_2or4bpp(c, d, adata);
795 break;
796 }
797 }
798
799 // Some 1bpp images apparently have the palette set to [001, 000],
800 // or other nonsense, instead of [777, 000].
801 // Try to handle that.
802 static void fix_dark_pal(deark *c, struct atari_img_decode_data *adata)
803 {
804 u32 ap[2];
805
806 if(adata->bpp!=1) return;
807
808 ap[0] = adata->pal[0]&0xffffff;
809 ap[1] = adata->pal[1]&0xffffff;
810
811 // Always respect white/black and black/white palettes.
812 if(ap[0]==0xffffff && ap[1]==0x000000) return; // The usual palette
813 if(ap[0]==0x000000 && ap[1]==0xffffff) return;
814
815 // Otherwise assume white/black, unless the user told us not to.
816 if(de_get_ext_option(c, "atari:respectpal")) return;
817
818 adata->pal[0] = DE_STOCKCOLOR_WHITE;
819 adata->pal[1] = DE_STOCKCOLOR_BLACK;
820 }
821
822 static void de_run_tinystuff(deark *c, de_module_params *mparams)
823 {
824 struct atari_img_decode_data *adata = NULL;
825 de_finfo *fi = NULL;
826 tinyctx *d = NULL;
827 i64 pos = 0;
828 i64 expected_min_file_size;
829 i64 expected_max_file_size;
830 int is_grayscale;
831
832 d = de_malloc(c, sizeof(tinyctx));
833
834 adata = de_malloc(c, sizeof(struct atari_img_decode_data));
835 adata->pal = d->pal;
836 adata->was_compressed = 1;
837
838 d->res_code = de_getbyte(pos);
839 pos++;
840 de_dbg(c, "resolution code: %u", (UI)d->res_code);
841
842 switch(d->res_code) {
843 case 0: case 3:
844 adata->bpp = 4;
845 adata->w = 320;
846 adata->h = 200;
847 break;
848 case 1: case 4:
849 adata->bpp = 2;
850 adata->w = 640;
851 adata->h = 200;
852 break;
853 case 2: case 5:
854 adata->bpp = 1;
855 adata->w = 640;
856 adata->h = 400;
857 break;
858 default:
859 de_err(c, "Invalid resolution code (%u). This is not a Tiny Stuff file.",
860 (UI)d->res_code);
861 goto done;
862 }
863
864 de_dbg_dimensions(c, adata->w, adata->h);
865 adata->ncolors = de_pow2(adata->bpp);
866 de_dbg(c, "colors: %d", (int)adata->ncolors);
867
868 if(d->res_code>=3) {
869 de_warn(c, "This image uses palette cycling animation, which is not supported.");
870 pos += 4; // skip animation_info
871 }
872
873 fmtutil_read_atari_palette(c, c->infile, pos, adata->pal, 16, adata->ncolors, 0);
874 fix_dark_pal(c, adata);
875 pos += 16*2;
876
877 d->num_control_bytes = de_getu16be(pos);
878 pos += 2;
879 de_dbg(c, "number of RLE control bytes: %d", (int)d->num_control_bytes);
880
881 d->num_data_words = de_getu16be(pos);
882 pos += 2;
883 d->data_words_nbytes = 2*d->num_data_words;
884 de_dbg(c, "number of RLE data words: %d (%d bytes)", (int)d->num_data_words,
885 (int)d->data_words_nbytes);
886
887 // It seems that files are often padded to the next multiple of 128 bytes,
888 // so don't warn about that.
889 expected_min_file_size = pos + d->num_control_bytes + d->data_words_nbytes;
890 expected_max_file_size = de_pad_to_n(expected_min_file_size, 128);
891 de_dbg(c, "expected file size: %"I64_FMT" or %"I64_FMT, expected_min_file_size,
892 expected_max_file_size);
893 if(c->infile->len<expected_min_file_size || c->infile->len>expected_max_file_size) {
894 de_warn(c, "Expected file size to be %"I64_FMT", but it is %"I64_FMT".",
895 expected_min_file_size, c->infile->len);
896 }
897
898 adata->unc_pixels = dbuf_create_membuf(c, 32000, 1);
899
900 if(!tiny_uncompress(c, d, adata, pos)) {
901 goto done;
902 }
903
904 is_grayscale = de_is_grayscale_palette(adata->pal, adata->ncolors);
905
906 adata->img = de_bitmap_create(c, adata->w, adata->h, is_grayscale?1:3);
907
908 fi = de_finfo_create(c);
909 fmtutil_atari_set_standard_density(c, adata, fi);
910
911 do_tinystuff_image(c, d, adata);
912 de_bitmap_write_to_file_finfo(adata->img, fi, 0);
913
914 done:
915 if(adata) {
916 de_bitmap_destroy(adata->img);
917 dbuf_close(adata->unc_pixels);
918 de_free(c, adata);
919 }
920 de_finfo_destroy(c, fi);
921 de_free(c, d);
922 }
923
924 static int de_identify_tinystuff(deark *c)
925 {
926 // TODO: Can we identify these files?
927 if(de_getbyte(0)>0x05) return 0;
928 if(de_input_file_has_ext(c, "tny") ||
929 de_input_file_has_ext(c, "tn1") ||
930 de_input_file_has_ext(c, "tn2") ||
931 de_input_file_has_ext(c, "tn3") ||
932 de_input_file_has_ext(c, "tn4"))
933 {
934 return 8;
935 }
936 return 0;
937 }
938
939 static void de_help_tinystuff(deark *c)
940 {
941 fmtutil_atari_help_palbits(c);
942 help_respectpal(c);
943 }
944
945 void de_module_tinystuff(deark *c, struct deark_module_info *mi)
946 {
947 mi->id = "tinystuff";
948 mi->desc = "Atari Tiny Stuff, a.k.a. Tiny image format";
949 mi->run_fn = de_run_tinystuff;
950 mi->identify_fn = de_identify_tinystuff;
951 mi->help_fn = de_help_tinystuff;
952 }
953
954 // **************************************************************************
955 // Doodle (.doo)
956 // **************************************************************************
957
958 static void de_run_doodle(deark *c, de_module_params *mparams)
959 {
960 struct atari_img_decode_data *adata = NULL;
961 de_finfo *fi = NULL;
962 u32 pal[2];
963
964 adata = de_malloc(c, sizeof(struct atari_img_decode_data));
965 adata->pal = pal;
966 adata->bpp = 1;
967
968 adata->w = 640;
969 adata->h = 400;
970 adata->ncolors = 2;
971 adata->pal[0] = DE_STOCKCOLOR_WHITE;
972 adata->pal[1] = DE_STOCKCOLOR_BLACK;
973
974 adata->unc_pixels = c->infile;
975 adata->img = de_bitmap_create(c, adata->w, adata->h, 1);
976 fi = de_finfo_create(c);
977 fmtutil_atari_set_standard_density(c, adata, fi);
978 fmtutil_atari_decode_image(c, adata);
979 de_bitmap_write_to_file_finfo(adata->img, fi, 0);
980
981 if(adata) {
982 de_bitmap_destroy(adata->img);
983 de_free(c, adata);
984 }
985 de_finfo_destroy(c, fi);
986 }
987
988 static int de_identify_doodle(deark *c)
989 {
990 if(c->infile->len!=32000) return 0;
991 if(de_input_file_has_ext(c, "doo")) {
992 return 10;
993 }
994 return 0;
995 }
996
997 void de_module_doodle(deark *c, struct deark_module_info *mi)
998 {
999 mi->id = "doodle";
1000 mi->desc = "Atari Doodle";
1001 mi->run_fn = de_run_doodle;
1002 mi->identify_fn = de_identify_doodle;
1003 }
1004
1005 // **************************************************************************
1006 // NEOchrome (.neo)
1007 // **************************************************************************
1008
1009 static void de_run_neochrome(deark *c, de_module_params *mparams)
1010 {
1011 struct atari_img_decode_data *adata = NULL;
1012 de_finfo *fi = NULL;
1013 unsigned int resolution_code;
1014 int is_grayscale;
1015 u32 pal[16];
1016
1017 adata = de_malloc(c, sizeof(struct atari_img_decode_data));
1018 adata->pal = pal;
1019
1020 resolution_code = (unsigned int)de_getu16be(2);
1021 de_dbg(c, "resolution code: %u", resolution_code);
1022 if(resolution_code!=0) {
1023 de_err(c, "Invalid or unsupported NEOchrome image (resolution=%d)", (int)resolution_code);
1024 goto done;
1025 }
1026
1027 // TODO: Warn about palette animation settings.
1028 // TODO: (Maybe) Use the embedded filename, if it seems valid.
1029
1030 adata->bpp = 4;
1031 adata->w = 320;
1032 adata->h = 200;
1033 adata->ncolors = de_pow2(adata->bpp);
1034 de_dbg(c, "dimensions: %d"DE_CHAR_TIMES"%d, colors: %d", (int)adata->w, (int)adata->h, (int)adata->ncolors);
1035
1036 fmtutil_read_atari_palette(c, c->infile, 4, adata->pal, 16, adata->ncolors, 0);
1037 adata->unc_pixels = dbuf_open_input_subfile(c->infile, 128, 32000);
1038 is_grayscale = de_is_grayscale_palette(adata->pal, adata->ncolors);
1039 adata->img = de_bitmap_create(c, adata->w, adata->h, is_grayscale?1:3);
1040 fi = de_finfo_create(c);
1041 fmtutil_atari_set_standard_density(c, adata, fi);
1042 fmtutil_atari_decode_image(c, adata);
1043 de_bitmap_write_to_file_finfo(adata->img, fi, 0);
1044
1045 done:
1046 if(adata) {
1047 dbuf_close(adata->unc_pixels);
1048 de_bitmap_destroy(adata->img);
1049 de_free(c, adata);
1050 }
1051 de_finfo_destroy(c, fi);
1052 }
1053
1054 static int de_identify_neochrome(deark *c)
1055 {
1056 if(de_input_file_has_ext(c, "neo")) {
1057 if(c->infile->len == 32128) {
1058 return 100;
1059 }
1060 else if(c->infile->len > 32128) {
1061 return 10;
1062 }
1063 }
1064 return 0;
1065 }
1066
1067 static void de_help_neochrome(deark *c)
1068 {
1069 fmtutil_atari_help_palbits(c);
1070 }
1071
1072 void de_module_neochrome(deark *c, struct deark_module_info *mi)
1073 {
1074 mi->id = "neochrome";
1075 mi->desc = "Atari NEOchrome image";
1076 mi->run_fn = de_run_neochrome;
1077 mi->identify_fn = de_identify_neochrome;
1078 mi->help_fn = de_help_neochrome;
1079 }
1080
1081 // **************************************************************************
1082 // NEOchrome animation (.ani)
1083 // **************************************************************************
1084
1085 static void de_run_neochrome_ani(deark *c, de_module_params *mparams)
1086 {
1087 struct atari_img_decode_data *adata = NULL;
1088 i64 width_in_bytes;
1089 i64 nframes;
1090 i64 bytes_per_frame;
1091 i64 frame;
1092 i64 k;
1093 u32 pal[16];
1094
1095 de_declare_fmt(c, "NEOchrome Animation");
1096
1097 de_warn(c, "NEOchrome Animation images may not be decoded correctly.");
1098
1099 adata = de_malloc(c, sizeof(struct atari_img_decode_data));
1100
1101 // TODO: What palette should we use?
1102 for(k=0; k<16; k++) {
1103 pal[k] = DE_MAKE_GRAY((unsigned int)(k*17));
1104 }
1105 adata->pal = pal;
1106 adata->bpp = 4;
1107 adata->ncolors = 16;
1108
1109 width_in_bytes = de_getu16be(4); // Always a multiple of 8
1110 adata->w = ((width_in_bytes+7)/8)*16;
1111 adata->h = de_getu16be(6);
1112 de_dbg_dimensions(c, adata->w, adata->h);
1113 if(!de_good_image_dimensions(c, adata->w, adata->h)) goto done;
1114
1115 bytes_per_frame = de_getu16be(8);
1116 bytes_per_frame -= 10;
1117 de_dbg(c, "bytes/frame: %d", (int)bytes_per_frame);
1118 if(bytes_per_frame<1) goto done;
1119
1120 nframes = de_getu16be(14);
1121 de_dbg(c, "number of frames: %d", (int)nframes);
1122 if(!de_good_image_count(c, nframes)) goto done;
1123
1124 for(frame=0; frame<nframes; frame++) {
1125 adata->unc_pixels = dbuf_open_input_subfile(c->infile, 22 + frame*bytes_per_frame, bytes_per_frame);
1126 adata->img = de_bitmap_create(c, adata->w, adata->h, 3);
1127
1128 fmtutil_atari_decode_image(c, adata);
1129 de_bitmap_write_to_file(adata->img, NULL, 0);
1130
1131 de_bitmap_destroy(adata->img);
1132 adata->img = NULL;
1133
1134 dbuf_close(adata->unc_pixels);
1135 adata->unc_pixels = NULL;
1136 }
1137
1138 done:
1139 de_free(c, adata);
1140 }
1141
1142 static int de_identify_neochrome_ani(deark *c)
1143 {
1144 if(!dbuf_memcmp(c->infile, 0, "\xba\xbe\xeb\xea", 4)) {
1145 return 100;
1146 }
1147 return 0;
1148 }
1149
1150 void de_module_neochrome_ani(deark *c, struct deark_module_info *mi)
1151 {
1152 mi->id = "neochrome_ani";
1153 mi->desc = "NEOchrome Animation";
1154 mi->run_fn = de_run_neochrome_ani;
1155 mi->identify_fn = de_identify_neochrome_ani;
1156 mi->flags |= DE_MODFLAG_NONWORKING;
1157 }
1158
1159 // **************************************************************************
1160 // Animatic Film (.flm)
1161 // **************************************************************************
1162
1163 static void de_run_animatic(deark *c, de_module_params *mparams)
1164 {
1165 struct atari_img_decode_data *adata = NULL;
1166 i64 nframes;
1167 i64 frame;
1168 i64 planespan, rowspan, framespan;
1169 i64 frame_bitmap_pos;
1170 u32 pal[16];
1171
1172 de_declare_fmt(c, "Animatic Film");
1173
1174 adata = de_malloc(c, sizeof(struct atari_img_decode_data));
1175
1176 nframes = de_getu16be(0);
1177 de_dbg(c, "number of frames: %d", (int)nframes);
1178 if(!de_good_image_count(c, nframes)) goto done;
1179
1180 adata->bpp = 4;
1181 adata->ncolors = 16;
1182 adata->pal = pal;
1183 de_dbg_indent(c, 1);
1184 fmtutil_read_atari_palette(c, c->infile, 2, adata->pal, 16, adata->ncolors, 0);
1185 de_dbg_indent(c, -1);
1186
1187 adata->w = de_getu16be(40);
1188 adata->h = de_getu16be(42);
1189 de_dbg_dimensions(c, adata->w, adata->h);
1190 if(!de_good_image_dimensions(c, adata->w, adata->h)) goto done;
1191
1192 planespan = 2*((adata->w+15)/16);
1193 rowspan = planespan*adata->bpp;
1194 framespan = rowspan*adata->h;
1195
1196 for(frame=0; frame<nframes; frame++) {
1197 frame_bitmap_pos = 64 + frame*framespan;
1198 de_dbg(c, "frame %d bitmap at %d", (int)frame, (int)frame_bitmap_pos);
1199
1200 adata->unc_pixels = dbuf_open_input_subfile(c->infile, frame_bitmap_pos, framespan);
1201 adata->img = de_bitmap_create(c, adata->w, adata->h, 3);
1202
1203 fmtutil_atari_decode_image(c, adata);
1204 de_bitmap_write_to_file(adata->img, NULL, 0);
1205
1206 de_bitmap_destroy(adata->img);
1207 adata->img = NULL;
1208
1209 dbuf_close(adata->unc_pixels);
1210 adata->unc_pixels = NULL;
1211 }
1212
1213 done:
1214 de_free(c, adata);
1215 }
1216
1217 static int de_identify_animatic(deark *c)
1218 {
1219 if(!dbuf_memcmp(c->infile, 48, "\x27\x18\x28\x18", 4)) {
1220 return 100;
1221 }
1222 return 0;
1223 }
1224
1225 static void de_help_animatic(deark *c)
1226 {
1227 fmtutil_atari_help_palbits(c);
1228 }
1229
1230 void de_module_animatic(deark *c, struct deark_module_info *mi)
1231 {
1232 mi->id = "animatic";
1233 mi->desc = "Animatic Film";
1234 mi->run_fn = de_run_animatic;
1235 mi->identify_fn = de_identify_animatic;
1236 mi->help_fn = de_help_animatic;
1237 }
1238
1239 // **************************************************************************
1240 // Atari .PI4/.PI9
1241 // **************************************************************************
1242
1243 static void decode_falcon_8bit_image(deark *c, struct atari_img_decode_data *adata, i64 pos)
1244 {
1245 i64 i, j, k;
1246 unsigned int v;
1247 unsigned int n;
1248 de_finfo *fi = NULL;
1249
1250 adata->img = de_bitmap_create(c, adata->w, adata->h, 3);
1251
1252 fi = de_finfo_create(c);
1253 if(adata->w==320 && adata->h==200) {
1254 fi->density.code = DE_DENSITY_UNK_UNITS;
1255 fi->density.xdens = 240.0;
1256 fi->density.ydens = 200.0;
1257 }
1258
1259 for(j=0; j<adata->h; j++) {
1260 for(i=0; i<adata->w; i++) {
1261 v = 0;
1262 for(k=0; k<8; k++) {
1263 n = (u32)de_getu16be(pos+j*adata->w + (i-i%16) +2*k);
1264 if(n&(1<<(15-i%16))) v |= 1<<k;
1265 }
1266 de_bitmap_setpixel_rgb(adata->img, i, j, adata->pal[v]);
1267 }
1268 }
1269
1270 de_bitmap_write_to_file_finfo(adata->img, fi, 0);
1271 de_bitmap_destroy(adata->img);
1272 adata->img = NULL;
1273 de_finfo_destroy(c, fi);
1274 }
1275
1276 static void do_atari_falcon_8bit_img(deark *c, i64 width, i64 height)
1277 {
1278 struct atari_img_decode_data *adata = NULL;
1279 i64 k;
1280 u8 cr, cg, cb;
1281 u32 pal[256];
1282
1283 adata = de_malloc(c, sizeof(struct atari_img_decode_data));
1284 de_zeromem(pal, sizeof(pal));
1285 adata->pal = pal;
1286 adata->bpp = 8;
1287 adata->ncolors = 256;
1288 adata->w = width;
1289 adata->h = height;
1290 de_dbg_dimensions(c, adata->w, adata->h);
1291
1292 for(k=0; k<256; k++) {
1293 cr = de_getbyte(k*4+0);
1294 cg = de_getbyte(k*4+1);
1295 cb = de_getbyte(k*4+3);
1296 pal[k] = DE_MAKE_RGB(cr, cg, cb);
1297 de_dbg_pal_entry(c, k, pal[k]);
1298 }
1299
1300 decode_falcon_8bit_image(c, adata, 1024);
1301
1302 de_free(c, adata);
1303 }
1304
1305 static void de_run_fpaint_pi4(deark *c, de_module_params *mparams)
1306 {
1307 do_atari_falcon_8bit_img(c, 320, 240);
1308 }
1309
1310 // Atari falcon 320x240
1311 static int de_identify_fpaint_pi4(deark *c)
1312 {
1313 if(c->infile->len==77824) {
1314 if(de_input_file_has_ext(c, "pi4") ||
1315 de_input_file_has_ext(c, "pi9"))
1316 {
1317 return 50; // Must be lower than fpaint_pi9
1318 }
1319 }
1320 return 0;
1321 }
1322
1323 void de_module_fpaint_pi4(deark *c, struct deark_module_info *mi)
1324 {
1325 mi->id = "fpaint_pi4";
1326 mi->desc = "Atari Falcon PI4 image";
1327 mi->run_fn = de_run_fpaint_pi4;
1328 mi->identify_fn = de_identify_fpaint_pi4;
1329 }
1330
1331 static void de_run_fpaint_pi9(deark *c, de_module_params *mparams)
1332 {
1333 do_atari_falcon_8bit_img(c, 320, 200);
1334 }
1335
1336 // Atari falcon 320x200
1337 static int de_identify_fpaint_pi9(deark *c)
1338 {
1339 int pi4_ext, pi9_ext;
1340
1341 if(c->infile->len!=77824 && c->infile->len!=65024) return 0;
1342
1343 pi4_ext = de_input_file_has_ext(c, "pi4");
1344 pi9_ext = de_input_file_has_ext(c, "pi9");
1345 if(!pi4_ext && !pi9_ext) return 0;
1346
1347 if(c->infile->len==65024) return 60;
1348
1349 // If file size is 77824, we need to distinguish between PI4 (320x240) and
1350 // PI9 (320x200) format.
1351 // Best guess is that if the last 12800 bytes are all 0, we should assume PI9.
1352 if(!dbuf_is_all_zeroes(c->infile, 65024, 12800)) {
1353 return 0; // Will be identified elsewhere as PI4.
1354 }
1355
1356 return 60; // PI9. Must be higher than the value PI4 uses.
1357 }
1358
1359 void de_module_fpaint_pi9(deark *c, struct deark_module_info *mi)
1360 {
1361 mi->id = "fpaint_pi9";
1362 mi->desc = "Atari Falcon PI9 image";
1363 mi->run_fn = de_run_fpaint_pi9;
1364 mi->identify_fn = de_identify_fpaint_pi9;
1365 }
1366
1367 // **************************************************************************
1368 // Atari .PI7
1369 // **************************************************************************
1370
1371 static void de_run_atari_pi7(deark *c, de_module_params *mparams)
1372 {
1373 do_atari_falcon_8bit_img(c, 640, 480);
1374 }
1375
1376 static int de_identify_atari_pi7(deark *c)
1377 {
1378 if(c->infile->len==308224) {
1379 if(de_input_file_has_ext(c, "pi7"))
1380 {
1381 return 50;
1382 }
1383 }
1384 return 0;
1385 }
1386
1387 void de_module_atari_pi7(deark *c, struct deark_module_info *mi)
1388 {
1389 mi->id = "atari_pi7";
1390 mi->desc = "Atari PI7 image";
1391 mi->run_fn = de_run_atari_pi7;
1392 mi->identify_fn = de_identify_atari_pi7;
1393 }
1394
1395 // **************************************************************************
1396 // Atari Falcon XGA
1397 // **************************************************************************
1398
1399 static void de_run_falcon_xga(deark *c, de_module_params *mparams)
1400 {
1401 struct atari_img_decode_data *adata = NULL;
1402 de_finfo *fi = NULL;
1403
1404 adata = de_malloc(c, sizeof(struct atari_img_decode_data));
1405 if(c->infile->len==153600) {
1406 adata->bpp = 16;
1407 adata->w = 320;
1408 adata->h = 240;
1409 }
1410 else {
1411 adata->bpp = 16;
1412 adata->w = 384;
1413 adata->h = 480;
1414 }
1415 de_dbg_dimensions(c, adata->w, adata->h);
1416 adata->unc_pixels = c->infile;
1417 adata->img = de_bitmap_create(c, adata->w, adata->h, 3);
1418 fi = de_finfo_create(c);
1419 if(adata->w==384 && adata->h == 480) {
1420 fi->density.code = DE_DENSITY_UNK_UNITS;
1421 fi->density.xdens = 384;
1422 fi->density.ydens = 640;
1423 }
1424 fmtutil_atari_decode_image(c, adata);
1425 de_bitmap_write_to_file_finfo(adata->img, fi, 0);
1426 de_bitmap_destroy(adata->img);
1427 de_finfo_destroy(c, fi);
1428 de_free(c, adata);
1429 }
1430
1431 static int de_identify_falcon_xga(deark *c)
1432 {
1433 if(c->infile->len==153600 || c->infile->len==368640) {
1434 if(de_input_file_has_ext(c, "xga"))
1435 {
1436 return 50;
1437 }
1438 }
1439 return 0;
1440 }
1441
1442 void de_module_falcon_xga(deark *c, struct deark_module_info *mi)
1443 {
1444 mi->id = "falcon_xga";
1445 mi->desc = "Atari Falcon XGA image";
1446 mi->run_fn = de_run_falcon_xga;
1447 mi->identify_fn = de_identify_falcon_xga;
1448 }
1449
1450 // **************************************************************************
1451 // Atari Falcon COKE (.tg1)
1452 // **************************************************************************
1453
1454 static void de_run_coke(deark *c, de_module_params *mparams)
1455 {
1456 i64 imgdatapos;
1457 struct atari_img_decode_data *adata = NULL;
1458 de_finfo *fi = NULL;
1459
1460 adata = de_malloc(c, sizeof(struct atari_img_decode_data));
1461 adata->bpp = 16;
1462 adata->w = de_getu16be(12);
1463 adata->h = de_getu16be(14);
1464 de_dbg_dimensions(c, adata->w, adata->h);
1465 imgdatapos = de_getu16be(16);
1466 de_dbg(c, "image data pos: %d", (int)imgdatapos);
1467
1468 adata->unc_pixels = dbuf_open_input_subfile(c->infile,
1469 imgdatapos, c->infile->len-imgdatapos);
1470 adata->img = de_bitmap_create(c, adata->w, adata->h, 3);
1471
1472 fi = de_finfo_create(c);
1473 fi->density.code = DE_DENSITY_UNK_UNITS;
1474 fi->density.xdens = 288;
1475 fi->density.ydens = 240;
1476
1477 fmtutil_atari_decode_image(c, adata);
1478 de_bitmap_write_to_file_finfo(adata->img, fi, 0);
1479
1480 if(adata) {
1481 dbuf_close(adata->unc_pixels);
1482 de_bitmap_destroy(adata->img);
1483 de_free(c, adata);
1484 }
1485 de_finfo_destroy(c, fi);
1486 }
1487
1488 static int de_identify_coke(deark *c)
1489 {
1490 if(!dbuf_memcmp(c->infile, 0, (const void*)"COKE format.", 12)) {
1491 return 100;
1492 }
1493 return 0;
1494 }
1495
1496 void de_module_coke(deark *c, struct deark_module_info *mi)
1497 {
1498 mi->id = "coke";
1499 mi->desc = "Atari Falcon COKE image (.TG1)";
1500 mi->run_fn = de_run_coke;
1501 mi->identify_fn = de_identify_coke;
1502 }
1503
1504 // **************************************************************************
1505 // Video Master .FLM, etc. (Amiga & Atari ST)
1506 // **************************************************************************
1507
1508 #define VMAS_FRAME_PAL_SIZE 32
1509 #define VMAS_FRAME_BITMAP_SIZE 8000
1510 #define VMAS_FRAME_TOTAL_SIZE (VMAS_FRAME_PAL_SIZE+VMAS_FRAME_BITMAP_SIZE)
1511
1512 static void de_run_videomaster(deark *c, de_module_params *mparams)
1513 {
1514 struct atari_img_decode_data *adata = NULL;
1515 de_finfo *fi = NULL;
1516 i64 nframes;
1517 i64 frameidx;
1518 i64 frames_startpos;
1519 i64 pos;
1520 de_color pal[16];
1521
1522 nframes = de_getu16be(6);
1523 de_dbg(c, "num frames: %u", (UI)nframes);
1524 frames_startpos = 32;
1525 if(frames_startpos + nframes*VMAS_FRAME_TOTAL_SIZE > c->infile->len) {
1526 de_err(c, "Invalid or truncated file");
1527 goto done;
1528 }
1529
1530 adata = de_malloc(c, sizeof(struct atari_img_decode_data));
1531 adata->bpp = 4;
1532 adata->w = 160;
1533 adata->h = 100;
1534 adata->pal = pal;
1535 adata->ncolors = 16;
1536 adata->unc_pixels = dbuf_create_membuf(c, VMAS_FRAME_BITMAP_SIZE, 0x1);
1537 adata->img = de_bitmap_create(c, adata->w, adata->h, 3);
1538 fi = de_finfo_create(c);
1539 // This might not be the right aspect ratio in all cases, but I think it's
1540 // probably better than nothing.
1541 fmtutil_atari_set_standard_density(c, adata, fi);
1542
1543 pos = frames_startpos;
1544 for(frameidx=0; frameidx<nframes; frameidx++) {
1545 de_dbg(c, "frame #%d at %"I64_FMT, (int)frameidx, pos);
1546 de_dbg_indent(c, 1);
1547 de_read_simple_palette(c, c->infile, pos, 16, 2, adata->pal, 16, DE_RDPALTYPE_AMIGA12BIT, 0);
1548 pos += VMAS_FRAME_PAL_SIZE;
1549
1550 de_dbg(c, "bitmap at %"I64_FMT, pos);
1551 dbuf_truncate(adata->unc_pixels, 0);
1552 dbuf_copy(c->infile, pos, VMAS_FRAME_BITMAP_SIZE, adata->unc_pixels);
1553 pos += VMAS_FRAME_BITMAP_SIZE;
1554
1555 fmtutil_atari_decode_image(c, adata);
1556 de_bitmap_write_to_file_finfo(adata->img, fi, DE_CREATEFLAG_OPT_IMAGE);
1557 de_dbg_indent(c, -1);
1558 }
1559
1560 done:
1561 if(adata) {
1562 dbuf_close(adata->unc_pixels);
1563 de_bitmap_destroy(adata->img);
1564 de_free(c, adata);
1565 }
1566 de_finfo_destroy(c, fi);
1567 }
1568
1569 static int de_identify_videomaster(deark *c)
1570 {
1571 if(!dbuf_memcmp(c->infile, 0, (const void*)"VMAS1", 5)) {
1572 return 100;
1573 }
1574 return 0;
1575 }
1576
1577 void de_module_videomaster(deark *c, struct deark_module_info *mi)
1578 {
1579 mi->id = "videomaster";
1580 mi->desc = "Video Master (.flm/.vid/.vsq)";
1581 mi->run_fn = de_run_videomaster;
1582 mi->identify_fn = de_identify_videomaster;
1583 }
Deark is a portable command-line utility that can decode certain types of files.