?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
iccprofile: Decode 'dict' data type
[deark.git] / modules / pcpaint.c
blobcb484ffc5d1fa6a9cb560cdc66422efa1b297b03
1 // This file is part of Deark.
2 // Copyright (C) 2016 Jason Summers
3 // See the file COPYING for terms of use.
4
5 // PCPaint PIC and CLP format
6
7 #include <deark-config.h>
8 #include <deark-private.h>
9 DE_DECLARE_MODULE(de_module_pcpaint);
10
11 struct pal_info {
12 i64 edesc;
13 i64 esize;
14 u8 *data;
15 };
16
17 struct localctx_struct;
18 typedef struct localctx_struct lctx;
19
20 enum screen_mode_type_enum {
21 SCREENMODETYPE_UNKNOWN = 0,
22 SCREENMODETYPE_BITMAP,
23 SCREENMODETYPE_TEXT
24 };
25
26 typedef void (*decoder_fn_type)(deark *c, lctx *d);
27
28 struct localctx_struct {
29 #define FMT_PIC 1
30 #define FMT_CLP 2
31 int file_fmt;
32 int ver;
33 de_encoding input_encoding;
34 int opt_keep_invis_chars;
35 de_finfo *fi;
36 i64 header_size;
37 i64 npwidth, height;
38 i64 pdwidth;
39 u8 plane_info;
40 u8 palette_flag;
41 u8 video_mode; // 0 = unknown
42 struct pal_info pal_info_mainfile;
43 struct pal_info pal_info_palfile;
44 struct pal_info *pal_info_to_use; // Points to _mainfile or _palfile
45 i64 num_rle_blocks;
46 dbuf *unc_pixels;
47 decoder_fn_type decoder_fn;
48 enum screen_mode_type_enum screen_mode_type;
49 };
50
51 static void set_density(deark *c, lctx *d)
52 {
53 if(!d->fi) return;
54
55 switch(d->video_mode) {
56 case 'A': // 320x200
57 case 'B':
58 case 'I':
59 case 'J':
60 case 'L':
61 d->fi->density.code = DE_DENSITY_UNK_UNITS;
62 d->fi->density.xdens = 240.0;
63 d->fi->density.ydens = 200.0;
64 break;
65 case 'H': // 720x348 (Hercules)
66 case 'N':
67 d->fi->density.code = DE_DENSITY_UNK_UNITS;
68 // Various sources suggest aspect ratios of 1.46, 1.55, 1.59, ...
69 d->fi->density.xdens = 155.0;
70 d->fi->density.ydens = 100.0;
71 break;
72 case 'E': // 640x350
73 case 'F':
74 case 'G':
75 d->fi->density.code = DE_DENSITY_UNK_UNITS;
76 d->fi->density.xdens = 480.0;
77 d->fi->density.ydens = 350.0;
78 break;
79 case 'K':
80 case 'R':
81 d->fi->density.code = DE_DENSITY_UNK_UNITS;
82 d->fi->density.xdens = 480.0;
83 d->fi->density.ydens = 400.0;
84 break;
85 case 'C':
86 case 'D':
87 d->fi->density.code = DE_DENSITY_UNK_UNITS;
88 d->fi->density.xdens = 480.0;
89 d->fi->density.ydens = 200.0;
90 break;
91 }
92 }
93
94 static void decode_text(deark *c, lctx *d)
95 {
96 i64 width_in_chars;
97 struct de_char_context *charctx = NULL;
98 struct de_char_screen *screen;
99 i64 i, j, k;
100 u8 ch, attr;
101 struct de_encconv_state es;
102
103 // TODO: This might not work for monochrome text mode (d->video_mode==0x32).
104
105 width_in_chars = d->npwidth / 2;
106
107 charctx = de_malloc(c, sizeof(struct de_char_context));
108 charctx->no_density = 1;
109 charctx->nscreens = 1;
110 charctx->screens = de_mallocarray(c, charctx->nscreens, sizeof(struct de_char_screen*));
111 charctx->screens[0] = de_malloc(c, sizeof(struct de_char_screen));
112 screen = charctx->screens[0];
113
114 screen->width = width_in_chars;
115 screen->height = d->height;
116
117 de_dbg(c, "dimensions: %d"DE_CHAR_TIMES"%d characters", (int)screen->width, (int)screen->height);
118
119 if(screen->height<1) goto done;
120
121 screen->cell_rows = de_mallocarray(c, screen->height, sizeof(struct de_char_cell*));
122 de_encconv_init(&es, d->input_encoding);
123
124 for(j=0; j<screen->height; j++) {
125 i64 j2;
126
127 j2 = screen->height-1-j;
128 screen->cell_rows[j2] = de_mallocarray(c, screen->width, sizeof(struct de_char_cell));
129
130 for(i=0; i<screen->width; i++) {
131 ch = dbuf_getbyte(d->unc_pixels, j*d->npwidth + i*2);
132 attr = dbuf_getbyte(d->unc_pixels, j*d->npwidth + i*2 + 1);
133
134 screen->cell_rows[j2][i].fgcol = (u32)(attr & 0x0f);
135 screen->cell_rows[j2][i].bgcol = (u32)((attr & 0xf0) >> 4);
136
137 // In "blank" regions, some files have nonsense characters, with the fg
138 // and bg colors the same. We turn them into spaces, so that copy/paste
139 // works right with our HTML output.
140 if(ch==0 ||
141 (screen->cell_rows[j2][i].fgcol==screen->cell_rows[j2][i].bgcol &&
142 !d->opt_keep_invis_chars))
143 {
144 screen->cell_rows[j2][i].codepoint = 32;
145 screen->cell_rows[j2][i].codepoint_unicode = 32;
146 }
147 else {
148 screen->cell_rows[j2][i].codepoint = (i32)ch;
149 screen->cell_rows[j2][i].codepoint_unicode = de_char_to_unicode_ex((i32)ch, &es);
150 }
151 }
152 }
153
154 for(k=0; k<16; k++) {
155 // TODO: Is this always the right palette? Maybe we can't ignore ->edesc
156 charctx->pal[k] = de_palette_pc16((int)k);
157 }
158
159 de_char_output_to_file(c, charctx);
160
161 done:
162 de_free_charctx(c, charctx);
163 }
164
165 // Create a standard RGB palette from raw RGB palette data
166 static void make_rgb_palette(deark *c, lctx *d, u32 *pal, i64 num_entries)
167 {
168 i64 k;
169 u8 cr1, cg1, cb1;
170 u8 cr2, cg2, cb2;
171 int has_8bit_samples = 0;
172 char tmps[64];
173
174 // Pre-scan
175 for(k=0; k<num_entries; k++) {
176 if(3*k+2 >= d->pal_info_to_use->esize) break;
177 cr1 = d->pal_info_to_use->data[3*k+0];
178 cg1 = d->pal_info_to_use->data[3*k+1];
179 cb1 = d->pal_info_to_use->data[3*k+2];
180 if(cr1>63 || cg1>63 || cb1>63) {
181 de_dbg(c, "detected 8-bit palette samples");
182 has_8bit_samples = 1;
183 break;
184 }
185 }
186
187 // For real
188 de_dbg_indent(c, 1);
189 for(k=0; k<num_entries; k++) {
190 if(3*k+2 >= d->pal_info_to_use->esize) break;
191 cr1 = d->pal_info_to_use->data[3*k+0];
192 cg1 = d->pal_info_to_use->data[3*k+1];
193 cb1 = d->pal_info_to_use->data[3*k+2];
194
195 if(has_8bit_samples) {
196 cr2 = (cr1<<2) | (cr1>>6);
197 cg2 = (cg1<<2) | (cg1>>6);
198 cb2 = (cb1<<2) | (cb1>>6);
199 pal[k] = DE_MAKE_RGB(cr2, cg2, cb2);
200 de_dbg_pal_entry(c, k, pal[k]);
201 }
202 else {
203 cr2 = de_scale_63_to_255(cr1);
204 cg2 = de_scale_63_to_255(cg1);
205 cb2 = de_scale_63_to_255(cb1);
206 pal[k] = DE_MAKE_RGB(cr2, cg2, cb2);
207 de_snprintf(tmps, sizeof(tmps), "(%2d,%2d,%2d) "DE_CHAR_RIGHTARROW" ",
208 (int)cr1, (int)cg1, (int)cb1);
209 de_dbg_pal_entry2(c, k, pal[k], tmps, NULL, NULL);
210 }
211 }
212 de_dbg_indent(c, -1);
213 }
214
215 static void decode_egavga16(deark *c, lctx *d)
216 {
217 u32 pal[16];
218 i64 i, j;
219 i64 k;
220 i64 plane;
221 u8 z[4];
222 i64 src_rowspan;
223 i64 src_planespan;
224 int palent;
225 de_bitmap *img = NULL;
226 char tmps[32];
227
228 de_dbg(c, "image type: 16-color EGA/VGA");
229 de_zeromem(pal, sizeof(pal));
230
231 // Read the palette
232 if(d->pal_info_to_use->edesc==0) {
233 de_dbg(c, "palette type: standard 16-color palette (no palette in file)");
234 for(k=0; k<16; k++) {
235 pal[k] = de_palette_pc16((int)k);
236 }
237 }
238 else if(d->pal_info_to_use->edesc==3) {
239 // An EGA palette. Indexes into the standard EGA
240 // 64-color palette.
241 de_dbg(c, "palette type: 16 indices into standard EGA 64-color palette");
242 for(k=0; k<16; k++) {
243 if(k >= d->pal_info_to_use->esize) break;
244 pal[k] = de_palette_ega64(d->pal_info_to_use->data[k]);
245 de_snprintf(tmps, sizeof(tmps), "%2d ", (int)d->pal_info_to_use->data[k]);
246 de_dbg_pal_entry2(c, k, pal[k], tmps, NULL, NULL);
247 }
248 }
249 else { // assuming edesc==5
250 de_dbg(c, "palette type: 16-color palette (in file)");
251 make_rgb_palette(c, d, pal, 16);
252 }
253
254 if(d->plane_info==0x31) {
255 d->pdwidth = de_pad_to_n(d->npwidth, 8);
256 src_rowspan = d->pdwidth/8;
257 src_planespan = src_rowspan*d->height;
258 }
259 else {
260 d->pdwidth = de_pad_to_2(d->npwidth);
261 src_rowspan = d->pdwidth/2;
262 src_planespan = 0;
263 }
264
265 img = de_bitmap_create2(c, d->npwidth, d->pdwidth, d->height, 3);
266
267 for(j=0; j<d->height; j++) {
268 for(i=0; i<d->pdwidth; i++) {
269 if(d->plane_info==0x31) {
270 for(plane=0; plane<4; plane++) {
271 z[plane] = de_get_bits_symbol(d->unc_pixels, 1, plane*src_planespan + j*src_rowspan, i);
272 }
273 palent = z[0] + 2*z[1] + 4*z[2] + 8*z[3];
274 }
275 else {
276 palent = de_get_bits_symbol(d->unc_pixels, 4, j*src_rowspan, i);
277 }
278 de_bitmap_setpixel_rgb(img, i, j, pal[palent]);
279 }
280 }
281
282 de_bitmap_write_to_file_finfo(img, d->fi, DE_CREATEFLAG_FLIP_IMAGE);
283
284 de_bitmap_destroy(img);
285 }
286
287 static void decode_vga256(deark *c, lctx *d)
288 {
289 u32 pal[256];
290 i64 k;
291 de_bitmap *img = NULL;
292
293 de_dbg(c, "image type: 256-color");
294 de_zeromem(pal, sizeof(pal));
295
296 // Read the palette
297 if(d->pal_info_to_use->edesc==0) {
298 de_dbg(c, "palette type: standard 256-color palette (no palette in file)");
299 for(k=0; k<256; k++) {
300 pal[k] = de_palette_vga256((int)k);
301 }
302 }
303 else {
304 de_dbg(c, "palette type: 256-color palette (in file)");
305 de_dbg(c, "decoding palette");
306 make_rgb_palette(c, d, pal, 256);
307 }
308
309 img = de_bitmap_create2(c, d->npwidth, d->pdwidth, d->height, 3);
310
311 de_convert_image_paletted(d->unc_pixels, 0,
312 8, img->width, pal, img, 0);
313
314 de_bitmap_write_to_file_finfo(img, d->fi, DE_CREATEFLAG_FLIP_IMAGE);
315
316 de_bitmap_destroy(img);
317 }
318
319 static void decode_bilevel(deark *c, lctx *d)
320 {
321 i64 src_rowspan;
322 u32 pal[2];
323 int is_grayscale;
324 i64 edesc = d->pal_info_to_use->edesc;
325 de_bitmap *img = NULL;
326
327 de_dbg(c, "image type: bilevel");
328
329 if(!d->unc_pixels) goto done;
330
331 pal[0] = DE_STOCKCOLOR_BLACK;
332 pal[1] = DE_STOCKCOLOR_WHITE; // default
333
334 if(edesc!=0 && edesc!=4 && edesc!=5) {
335 de_warn(c, "The colors in this image might not be handled correctly (edesc=%d)",
336 (int)edesc);
337 }
338
339 if(edesc==4 || edesc==5) {
340 make_rgb_palette(c, d, pal, 2);
341 }
342
343 // PCPaint's CGA and EGA 2-color modes used gray shade 170 instead of
344 // white (255). Maybe they should be interpreted as white, but for
345 // historical accuracy I'll go with gray170.
346 if(edesc==0 && (d->video_mode==0x43 || d->video_mode==0x45)) {
347 pal[1] = DE_MAKE_GRAY(170);
348 }
349
350 d->pdwidth = de_pad_to_n(d->npwidth, 8);
351 src_rowspan = d->pdwidth/8;
352 is_grayscale = de_is_grayscale_palette(pal, 2);
353 img = de_bitmap_create2(c, d->npwidth, d->pdwidth, d->height, is_grayscale?1:3);
354
355 de_convert_image_paletted(d->unc_pixels, 0,
356 1, src_rowspan, pal, img, 0);
357
358 de_bitmap_write_to_file_finfo(img, d->fi, DE_CREATEFLAG_FLIP_IMAGE);
359
360 done:
361 de_bitmap_destroy(img);
362 }
363
364 static void decode_cga4(deark *c, lctx *d)
365 {
366 i64 k;
367 i64 src_rowspan;
368 u32 pal[4];
369 u8 pal_id = 0;
370 u8 border_col = 0;
371 de_bitmap *img = NULL;
372
373 de_dbg(c, "image type: CGA 4-color");
374
375 if(!d->unc_pixels) goto done;
376
377 if(d->pal_info_to_use->edesc==1) {
378 // Image includes information about which CGA 4-color palette it uses.
379
380 // This assumes PIC format. That should be the case, since edesc will
381 // be zero for CLP format (unless we are reading the palette from a separate
382 // PIC file).
383 if(d->pal_info_to_use->esize >= 1)
384 pal_id = d->pal_info_to_use->data[0];
385 if(d->pal_info_to_use->esize >= 2)
386 border_col = d->pal_info_to_use->data[1];
387 de_dbg(c, "pal_id=0x%02x border=0x%02x", pal_id, border_col);
388
389 for(k=0; k<4; k++) {
390 pal[k] = de_palette_pcpaint_cga4(pal_id, (int)k);
391 }
392
393 // Replace the first palette color with the border/background color.
394 pal[0] = de_palette_pc16(border_col);
395 }
396 else {
397 // No palette specified in the file. Use palette #2 by default.
398 for(k=0; k<4; k++) {
399 pal[k] = de_palette_pcpaint_cga4(2, (int)k);
400 }
401 }
402
403 d->pdwidth = de_pad_to_4(d->npwidth);
404 src_rowspan = d->pdwidth/4;
405 img = de_bitmap_create2(c, d->npwidth, d->pdwidth, d->height, 3);
406
407 de_convert_image_paletted(d->unc_pixels, 0,
408 2, src_rowspan, pal, img, 0);
409
410 de_bitmap_write_to_file_finfo(img, d->fi, DE_CREATEFLAG_FLIP_IMAGE);
411
412 done:
413 de_bitmap_destroy(img);
414 }
415
416 // decompress one block
417 // Writes decompressed bytes to d->unc_pixels.
418 // packed_data_size does not include header size.
419 // Returns 0 on error.
420 static int decompress_block(deark *c, lctx *d,
421 i64 pos1, i64 packed_data_size, u8 run_marker)
422 {
423 i64 pos = pos1;
424 i64 end_of_this_block;
425 u8 x;
426 i64 run_length;
427
428 end_of_this_block = pos1 + packed_data_size;
429
430 while(pos<end_of_this_block) {
431 x = de_getbyte_p(&pos);
432 if(x!=run_marker) {
433 // An non-compressed part of the image
434 dbuf_writebyte(d->unc_pixels, x);
435 continue;
436 }
437
438 // A compressed run.
439 x = de_getbyte_p(&pos);
440 if(x!=0) {
441 // If nonzero, this byte is the run length.
442 run_length = (i64)x;
443 }
444 else {
445 // If zero, it is followed by a 16-bit run length
446 run_length = de_getu16le_p(&pos);
447 }
448
449 // Read the byte value to repeat (run_length) times.
450 x = de_getbyte_p(&pos);
451 dbuf_write_run(d->unc_pixels, x, run_length);
452 }
453
454 return 1;
455 }
456
457 // Decompress multiple blocks of compressed pixels.
458 // This is for PIC format only.
459 static int decompress_pixels(deark *c, lctx *d)
460 {
461 i64 pos;
462 i64 i;
463 i64 packed_block_size;
464 i64 unpacked_block_size;
465 u8 run_marker;
466 int retval = 1;
467 i64 end_of_this_block;
468 int saved_indent_level;
469
470 de_dbg_indent_save(c, &saved_indent_level);
471 if(d->num_rle_blocks<1) {
472 // Not compressed
473 retval = 1;
474 goto done;
475 }
476
477 d->unc_pixels = dbuf_create_membuf(c, 16384, 0);
478 dbuf_set_length_limit(d->unc_pixels, (d->pdwidth+7) * d->height);
479
480 de_dbg(c, "decompressing image");
481 de_dbg_indent(c, 1);
482 pos = d->header_size;
483
484 for(i=0; i<d->num_rle_blocks; i++) {
485 de_dbg3(c, "block #%d at %"I64_FMT, (int)i, pos);
486 de_dbg_indent(c, 1);
487 // start_of_this_block = pos;
488 packed_block_size = de_getu16le(pos);
489 // block size includes the 5-byte header, so it can't be < 5.
490 if(packed_block_size<5) packed_block_size=5;
491 end_of_this_block = pos + packed_block_size; // Remember where this block ends
492 unpacked_block_size = de_getu16le(pos+2);
493 run_marker = de_getbyte(pos+4);
494 pos+=5;
495
496 de_dbg3(c, "packed size: %"I64_FMT, packed_block_size);
497 de_dbg3(c, "unpacked size: %"I64_FMT, unpacked_block_size);
498 de_dbg3(c, "run marker: 0x%02x", (UI)run_marker);
499
500 if(!decompress_block(c, d, pos, packed_block_size-5, run_marker)) {
501 goto done;
502 }
503 de_dbg_indent(c, -1);
504
505 pos = end_of_this_block;
506 }
507
508 de_dbg_indent(c, -1);
509 de_dbg(c, "decompressed to %"I64_FMT" bytes", d->unc_pixels->len);
510 retval = 1;
511
512 done:
513 de_dbg_indent_restore(c, saved_indent_level);
514 return retval;
515 }
516
517 static int do_read_palette_data(deark *c, lctx *d, dbuf *f, struct pal_info *palinfo)
518 {
519 palinfo->edesc = dbuf_getu16le(f, 13);
520 palinfo->esize = dbuf_getu16le(f, 15);
521 palinfo->data = de_malloc(c, palinfo->esize);
522 dbuf_read(f, palinfo->data, 17, palinfo->esize);
523 return 1;
524 }
525
526 // Figure out if we're supposed to read the palette from an alternate file.
527 // If so, open it and read a few fields from it. Modify settings so that
528 // we will read the palette from the alternate file.
529 // The palette file is assumed to be in PIC format.
530 static int do_read_alt_palette_file(deark *c, lctx *d)
531 {
532 const char *palfn;
533 dbuf *palfile = NULL;
534 int retval = 0;
535 i64 magic;
536
537 palfn = de_get_ext_option(c, "palfile");
538 if(!palfn) palfn = de_get_ext_option(c, "file2");
539 if(!palfn) {
540 retval = 1;
541 goto done;
542 }
543
544 de_dbg(c, "[reading palette from alternate file]");
545
546 palfile = dbuf_open_input_file(c, palfn);
547 if(!palfile) {
548 goto done;
549 }
550
551 magic = dbuf_getu16le(palfile, 0);
552 if(magic!=0x1234) {
553 de_err(c, "Palette file is not in PIC format.");
554 goto done;
555 }
556
557 do_read_palette_data(c, d, palfile, &d->pal_info_palfile);
558
559 if(d->pal_info_palfile.edesc==0) {
560 de_warn(c, "Palette file does not contain palette information.");
561 retval = 1;
562 goto done;
563 }
564
565 d->pal_info_to_use = &d->pal_info_palfile;
566 retval = 1;
567
568 done:
569 dbuf_close(palfile);
570 return retval;
571 }
572
573 // Determine if we can decode this type of image.
574 // Sets d->decoder_fn and d->screen_mode_type.
575 // If image can't be decoded, prints an error and returns 0.
576 static int do_set_up_decoder(deark *c, lctx *d)
577 {
578 i64 edesc;
579
580 edesc = d->pal_info_to_use->edesc; // For brevity
581
582 if(d->video_mode>='0' && d->video_mode<='3') {
583 d->screen_mode_type = SCREENMODETYPE_TEXT;
584 d->decoder_fn = decode_text;
585 }
586 else if(d->plane_info==0x01) {
587 // Expected video mode(s): 0x43, 0x45, 0x48, 0x4f, 0x50, 0x55
588 // CGA or EGA or VGA or Hercules 2-color
589 d->screen_mode_type = SCREENMODETYPE_BITMAP;
590 d->decoder_fn = decode_bilevel;
591 }
592 else if(d->plane_info==0x02 && (edesc==0 || edesc==1)) {
593 // Expected video mode(s): 0x41
594 d->screen_mode_type = SCREENMODETYPE_BITMAP;
595 d->decoder_fn = decode_cga4;
596 }
597 else if(d->plane_info==0x04 && edesc==3) {
598 d->screen_mode_type = SCREENMODETYPE_BITMAP;
599 d->decoder_fn = decode_egavga16;
600 }
601 else if((d->plane_info==0x04 || d->plane_info==0x31) &&
602 (edesc==0 || edesc==3 || edesc==5))
603 {
604 // Expected video mode(s): 0x4d, 0x47
605 d->screen_mode_type = SCREENMODETYPE_BITMAP;
606 d->decoder_fn = decode_egavga16;
607 }
608 else if(d->plane_info==0x08 && (edesc==0 || edesc==4)) {
609 // Expected video mode(s): 0x4c
610 d->screen_mode_type = SCREENMODETYPE_BITMAP;
611 d->decoder_fn = decode_vga256;
612 }
613
614 if(d->decoder_fn) {
615 de_dbg2(c, "image type: evideo=0x%02x, bitsinf=0x%02x, edesc=%d",
616 d->video_mode, d->plane_info, (int)edesc);
617 return 1;
618 }
619
620 de_err(c, "This type of PCPaint %s is not supported (evideo=0x%02x, bitsinf=0x%02x, edesc=%d)",
621 (d->file_fmt==FMT_CLP) ? "CLP" : "PIC",
622 d->video_mode, d->plane_info, (int)edesc);
623
624 return 0;
625 }
626
627 static void de_run_pcpaint_pic(deark *c, lctx *d, de_module_params *mparams)
628 {
629 int saved_indent_level;
630
631 de_dbg_indent_save(c, &saved_indent_level);
632
633 de_declare_fmt(c, "PCPaint PIC");
634
635 d->fi = de_finfo_create(c);
636
637 de_dbg(c, "header at %d", 0);
638 de_dbg_indent(c, 1);
639
640 d->npwidth = de_getu16le(2);
641 d->pdwidth = d->npwidth; // default
642 d->height = de_getu16le(4);
643 de_dbg_dimensions(c, d->npwidth, d->height);
644
645 d->plane_info = de_getbyte(10);
646 d->palette_flag = de_getbyte(11);
647
648 de_dbg(c, "plane info: 0x%02x", (int)d->plane_info);
649 de_dbg(c, "palette flag: 0x%02x", (int)d->palette_flag);
650
651 if(d->palette_flag==0xff) {
652 d->ver = 2;
653 }
654
655 if(d->ver!=2) {
656 de_err(c, "This version of PCPaint PIC is not supported");
657 goto done;
658 }
659
660 d->video_mode = de_getbyte(12);
661 de_dbg(c, "video mode: 0x%02x", (int)d->video_mode);
662
663 do_read_palette_data(c, d, c->infile, &d->pal_info_mainfile);
664 de_dbg(c, "edesc: %d", (int)d->pal_info_mainfile.edesc);
665 de_dbg(c, "esize: %d", (int)d->pal_info_mainfile.esize);
666
667 if(d->pal_info_mainfile.esize>0) {
668 de_dbg(c, "palette or other info at %d", 17);
669 }
670
671 set_density(c, d);
672
673 d->pal_info_to_use = &d->pal_info_mainfile; // tentative
674 if(!do_read_alt_palette_file(c, d)) goto done;
675
676 d->num_rle_blocks = de_getu16le(17+d->pal_info_mainfile.esize);
677
678 d->header_size = 17 + d->pal_info_mainfile.esize + 2;
679
680 de_dbg(c, "num rle blocks: %d", (int)d->num_rle_blocks);
681 de_dbg_indent(c, -1);
682
683 de_dbg(c, "image data at %d", (int)d->header_size);
684 de_dbg_indent(c, 1);
685 if(!do_set_up_decoder(c, d)) goto done;
686 if(d->screen_mode_type==SCREENMODETYPE_BITMAP) {
687 if(!de_good_image_dimensions(c, d->npwidth, d->height)) goto done;
688 }
689
690 if(d->num_rle_blocks>0) {
691 // Image is compressed.
692 decompress_pixels(c, d);
693 }
694 else {
695 // Image is not compressed.
696 d->unc_pixels = dbuf_open_input_subfile(c->infile, d->header_size,
697 c->infile->len-d->header_size);
698 }
699
700 d->decoder_fn(c, d);
701
702 done:
703 de_dbg_indent_restore(c, saved_indent_level);
704 }
705
706 static void de_run_pcpaint_clp(deark *c, lctx *d, de_module_params *mparams)
707 {
708 i64 file_size;
709 u8 run_marker;
710 int is_compressed;
711 int saved_indent_level;
712
713 de_dbg_indent_save(c, &saved_indent_level);
714
715 de_declare_fmt(c, "PCPaint CLP");
716
717 de_dbg(c, "header at %d", 0);
718 de_dbg_indent(c, 1);
719
720 file_size = de_getu16le(0);
721 de_dbg(c, "reported file size: %"I64_FMT, file_size);
722 if(file_size != c->infile->len) {
723 if(file_size==0x1234) {
724 de_warn(c, "This is probably a .PIC file, not a CLIP file.");
725 }
726 else {
727 de_warn(c, "Reported file size (%"I64_FMT") does not equal actual file size (%"I64_FMT"). "
728 "Format may not be correct.", file_size, c->infile->len);
729 }
730 }
731
732 d->npwidth = de_getu16le(2);
733 d->pdwidth = d->npwidth; // default
734 d->height = de_getu16le(4);
735 de_dbg_dimensions(c, d->npwidth, d->height);
736
737 d->plane_info = de_getbyte(10);
738
739 is_compressed = (d->plane_info==0xff);
740
741 if(is_compressed) {
742 d->header_size = 13;
743 d->plane_info = de_getbyte(11);
744 }
745 else {
746 d->header_size = 11;
747 }
748 de_dbg(c, "compressed: %d", (int)is_compressed);
749 de_dbg(c, "plane info: 0x%02x", (int)d->plane_info);
750
751 de_dbg_indent(c, -1);
752
753 // The colors probably won't be right, but we have no way to tell what palette
754 // is used by a CLP image.
755 d->video_mode = 0;
756 d->pal_info_mainfile.edesc = 0;
757 d->pal_info_mainfile.esize = 0;
758
759 d->pal_info_to_use = &d->pal_info_mainfile; // tentative
760 if(!do_read_alt_palette_file(c, d)) goto done;
761
762 de_dbg(c, "image data at %"I64_FMT, d->header_size);
763 de_dbg_indent(c, 1);
764 if(!do_set_up_decoder(c, d)) goto done;
765
766 if(is_compressed) {
767 run_marker = de_getbyte(12);
768 de_dbg3(c, "run marker: 0x%02x", (UI)run_marker);
769
770 de_dbg(c, "decompressing image");
771 de_dbg_indent(c, 1);
772 d->unc_pixels = dbuf_create_membuf(c, 16384, 0);
773 dbuf_set_length_limit(d->unc_pixels, (d->pdwidth+7) * d->height);
774
775 if(!decompress_block(c, d, d->header_size,
776 c->infile->len - d->header_size, run_marker))
777 {
778 goto done;
779 }
780 de_dbg_indent(c, -1);
781 de_dbg(c, "decompressed to %"I64_FMT" bytes", d->unc_pixels->len);
782 }
783 else {
784 d->unc_pixels = dbuf_open_input_subfile(c->infile,
785 d->header_size, c->infile->len-d->header_size);
786 }
787
788 d->decoder_fn(c, d);
789
790 done:
791 de_dbg_indent_restore(c, saved_indent_level);
792 }
793
794 // Dispatch to either pcpaint_pic or pcpaint_clp.
795 static void de_run_pcpaint(deark *c, de_module_params *mparams)
796 {
797 // 0=unknown, 1=pic, 2=clp
798 const char *pcpaintfmt;
799 u8 buf[16];
800 lctx *d;
801
802 d = de_malloc(c, sizeof(lctx));
803
804 d->input_encoding = de_get_input_encoding(c, NULL, DE_ENCODING_CP437_G);
805
806 pcpaintfmt = de_get_ext_option(c, "pcpaint:fmt");
807 if(pcpaintfmt) {
808 if(!de_strcmp(pcpaintfmt, "pic")) {
809 d->file_fmt = FMT_PIC;
810 }
811 else if(!de_strcmp(pcpaintfmt, "clp")) {
812 d->file_fmt = FMT_CLP;
813 }
814 else if(!de_strcmp(pcpaintfmt, "clip")) {
815 d->file_fmt = FMT_CLP;
816 }
817 }
818
819 if(!d->file_fmt) {
820 // File subtype not given by user. Try to detect it.
821 de_read(buf, 0, 16);
822 if(buf[0]==0x34 && buf[1]==0x12) {
823 if(c->infile->len==0x1234) {
824 // Pathological case where both formats could start with 0x1234.
825 if(buf[10]==0xff) { // definitely a compressed CLP
826 d->file_fmt = FMT_CLP;
827 }
828 else {
829 de_warn(c, "Format can't be reliably identified. Try \"-opt pcpaint:fmt=clp\" if necessary.");
830 d->file_fmt = FMT_PIC;
831 }
832 }
833 else {
834 d->file_fmt = FMT_PIC;
835 }
836 }
837 else {
838 d->file_fmt = FMT_CLP;
839 }
840 }
841
842 d->opt_keep_invis_chars = de_get_ext_option_bool(c, "pcpaint:invistext", 0);
843
844 if(d->file_fmt==FMT_CLP) {
845 de_run_pcpaint_clp(c, d, mparams);
846 }
847 else {
848 de_run_pcpaint_pic(c, d, mparams);
849 }
850
851 if(d->unc_pixels) dbuf_close(d->unc_pixels);
852 de_finfo_destroy(c, d->fi);
853 de_free(c, d->pal_info_mainfile.data);
854 de_free(c, d->pal_info_palfile.data);
855 de_free(c, d);
856 }
857
858 static int de_identify_pcpaint(deark *c)
859 {
860 u8 buf[12];
861 int pic_ext, clp_ext;
862 i64 x;
863
864 pic_ext = de_input_file_has_ext(c, "pic");
865
866 de_read(buf, 0, 12);
867 if(buf[0]==0x34 && buf[1]==0x12 && buf[11]==0xff) {
868 return pic_ext ? 100 : 50;
869 }
870
871 clp_ext = de_input_file_has_ext(c, "clp");
872 if(clp_ext) {
873 x = de_getu16le_direct(&buf[0]);
874 if(x==c->infile->len) {
875 return 50;
876 }
877 }
878
879 return 0;
880 }
881
882 static void de_help_pcpaint(deark *c)
883 {
884 de_msg(c, "-file2 <file.pic> : PIC file to read the palette from");
885 de_msg(c, "-opt pcpaint:fmt=pic : Assume PIC format");
886 de_msg(c, "-opt pcpaint:fmt=clp : Assume CLP format");
887 }
888
889 void de_module_pcpaint(deark *c, struct deark_module_info *mi)
890 {
891 mi->id = "pcpaint";
892 mi->desc = "PCPaint PIC or CLP image";
893 mi->run_fn = de_run_pcpaint;
894 mi->identify_fn = de_identify_pcpaint;
895 mi->help_fn = de_help_pcpaint;
896 }
Deark is a portable command-line utility that can decode certain types of files.