?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
arc.c: Rearranged some functions
[deark.git] / modules / rosprite.c
blob7ad27814922e61b7272236e50d3211fd6561eccd
1 // This file is part of Deark.
2 // Copyright (C) 2016 Jason Summers
3 // See the file COPYING for terms of use.
4
5 // Acorn Sprite / RISC OS Sprite
6
7 #include <deark-config.h>
8 #include <deark-private.h>
9 DE_DECLARE_MODULE(de_module_rosprite);
10
11 struct old_mode_info {
12 u32 mode;
13 int fgbpp;
14 int xdpi;
15 int ydpi;
16 };
17 // Screen mode list at: http://www.riscos.com/support/users/userguide3/book3b/book3_17.html
18 // TODO: Find reliable information about DPI fields.
19 static const struct old_mode_info old_mode_info_arr[] = {
20 {0, 1, 90, 45},
21 {1, 2, 45, 45},
22 {2, 4, 0, 0},
23 {4, 1, 45, 45},
24 {5, 2, 0, 0},
25 {8, 2, 90, 45},
26 {9, 4, 45, 45},
27 {10, 8, 0, 0},
28 {11, 2, 0, 0},
29 {12, 4, 90, 45},
30 {13, 8, 45, 45},
31 {14, 4, 0, 0},
32 {15, 8, 90, 45},
33 {16, 4, 0, 0},
34 {17, 4, 0, 0},
35 {18, 1, 90, 90},
36 {19, 2, 90, 90},
37 {20, 4, 90, 90},
38 {21, 8, 90, 90},
39 {22, 4, 0, 0},
40 {23, 1, 0, 0},
41 {24, 8, 0, 0},
42 {25, 1, 0, 0},
43 {26, 2, 0, 0},
44 {27, 4, 90, 90},
45 {28, 8, 90, 90},
46 {29, 1, 0, 0},
47 {30, 2, 0, 0},
48 {31, 4, 90, 90},
49 {32, 8, 90, 90},
50 {33, 1, 0, 0},
51 {34, 2, 0, 0},
52 {35, 4, 0, 0},
53 {36, 8, 90, 45},
54 {37, 1, 0, 0},
55 {38, 2, 0, 0},
56 {39, 4, 0, 0},
57 {40, 8, 0, 0},
58 {41, 1, 0, 0},
59 {42, 2, 0, 0},
60 {43, 4, 0, 0},
61 {44, 1, 0, 0},
62 {45, 2, 0, 0},
63 {46, 4, 0, 0},
64 {47, 8, 0, 0},
65 {48, 4, 0, 0},
66 {49, 8, 0, 0},
67
68 // I have some mode-107 files, but I don't know how standard this is.
69 {107, 16, 0, 0},
70
71 {1000, 0, 0, 0}
72 };
73
74 struct page_ctx {
75 i64 fgbpp;
76 i64 maskbpp;
77 i64 width_in_words;
78 i64 first_bit, last_bit;
79 i64 width, height;
80
81 i64 x_idx_of_first_src_fg_pixel_to_convert; // dstfg[0] <- srcfg[x.i.o.f.s.f.p.t.c]
82 i64 num_fg_x_pixels_to_convert;
83 i64 x_idx_of_first_src_mask_pixel_to_convert;
84 i64 mask_x_offset; // dstmask[m.x.o] <- srcmask[x.i.o.f.s.m.p.t.c]
85 i64 num_mask_x_pixels_to_convert;
86
87 i64 xdpi, ydpi;
88 i64 num_padding_pixels_at_start_of_row;
89 u32 mode;
90 int has_mask;
91 #define MASK_TYPE_OLD 1 // Binary transparency, fgbpp bits/pixel
92 #define MASK_TYPE_NEW_1 2 // Binary transparency, 8 bits/pixel
93 #define MASK_TYPE_NEW_8 3 // Alpha transparency, 8 bits/pixel
94 int mask_type;
95 i64 mask_rowspan;
96 i64 image_offset;
97 i64 mask_offset;
98
99 int has_custom_palette;
100 i64 custom_palette_pos;
101 i64 custom_palette_ncolors;
102 u32 pal[256];
103 };
104
105 typedef struct localctx_struct {
106 i64 num_images;
107 } lctx;
108
109 static const u32 pal4[4] = {
110 0xffffff,0xbbbbbb,0x777777,0x000000
111 };
112
113 static u32 getpal4(int k)
114 {
115 if(k<0 || k>3) return 0;
116 return pal4[k];
117 }
118
119 static const u32 pal16[16] = {
120 0xffffff,0xdddddd,0xbbbbbb,0x999999,0x777777,0x555555,0x333333,0x000000,
121 0x4499ff,0xeeee00,0x00cc00,0xdd0000,0xeeeebb,0x558800,0xffbb00,0x00bbff
122 };
123
124 static u32 getpal16(int k)
125 {
126 if(k<0 || k>15) return 0;
127 return pal16[k];
128 }
129
130 static u32 getpal256(int k)
131 {
132 u8 r, g, b;
133 if(k<0 || k>255) return 0;
134 r = k%8 + ((k%32)/16)*8;
135 g = k%4 + ((k%128)/32)*4;
136 b = (u8)(k%4 + ((k%16)/8)*4 + (k/128)*8);
137 r = (r<<4)|r;
138 g = (g<<4)|g;
139 b = (b<<4)|b;
140 return DE_MAKE_RGB(r,g,b);
141 }
142
143 static void do_image(deark *c, lctx *d, struct page_ctx *pg, de_finfo *fi)
144 {
145 de_bitmap *img = NULL;
146 de_bitmap *mask = NULL;
147 i64 i, j;
148 u8 n;
149 de_color clr;
150 int is_grayscale;
151 int bypp;
152
153 if(pg->fgbpp<=8) {
154 is_grayscale = de_is_grayscale_palette(pg->pal, ((i64)1)<<pg->fgbpp);
155 }
156 else {
157 is_grayscale = 0;
158 }
159
160 bypp = is_grayscale?1:3;
161 if(pg->has_mask) bypp++;
162
163 if(c->padpix) {
164 pg->num_fg_x_pixels_to_convert = (pg->width_in_words*32)/pg->fgbpp;
165 pg->x_idx_of_first_src_fg_pixel_to_convert = 0;
166 if(pg->mask_type==MASK_TYPE_OLD) {
167 pg->x_idx_of_first_src_mask_pixel_to_convert = 0;
168 pg->mask_x_offset = 0;
169 pg->num_mask_x_pixels_to_convert = pg->num_fg_x_pixels_to_convert;
170 }
171 else {
172 pg->x_idx_of_first_src_mask_pixel_to_convert = 0;
173 // Best guess is that new-style masks don't have initial padding pixels
174 pg->mask_x_offset = pg->num_padding_pixels_at_start_of_row;
175 pg->num_mask_x_pixels_to_convert = pg->mask_rowspan;
176 }
177 }
178 else {
179 pg->num_fg_x_pixels_to_convert = pg->width;
180 pg->x_idx_of_first_src_fg_pixel_to_convert = pg->num_padding_pixels_at_start_of_row;
181 if(pg->mask_type==MASK_TYPE_OLD) {
182 pg->x_idx_of_first_src_mask_pixel_to_convert = pg->x_idx_of_first_src_fg_pixel_to_convert;
183 pg->mask_x_offset = 0;
184 pg->num_mask_x_pixels_to_convert = pg->num_fg_x_pixels_to_convert;
185 }
186 else {
187 pg->x_idx_of_first_src_mask_pixel_to_convert = 0;
188 pg->mask_x_offset = 0;
189 pg->num_mask_x_pixels_to_convert = pg->num_fg_x_pixels_to_convert;
190 }
191 }
192
193 img = de_bitmap_create(c, pg->num_fg_x_pixels_to_convert, pg->height, bypp);
194
195 if(pg->xdpi>0) {
196 fi->density.code = DE_DENSITY_DPI;
197 fi->density.xdens = (double)pg->xdpi;
198 fi->density.ydens = (double)pg->ydpi;
199 }
200
201 de_dbg(c, "image data at %d", (int)pg->image_offset);
202
203 for(j=0; j<pg->height; j++) {
204 for(i=0; i<pg->num_fg_x_pixels_to_convert; i++) {
205 i64 i_adj;
206
207 i_adj = i+pg->x_idx_of_first_src_fg_pixel_to_convert;
208
209 if(pg->fgbpp==32) {
210 clr = dbuf_getRGB(c->infile, pg->image_offset + 4*pg->width_in_words*j + 4*i_adj, 0);
211 }
212 else if(pg->fgbpp==16) {
213 clr = (de_color)de_getu16le(pg->image_offset + 4*pg->width_in_words*j + i_adj*2);
214 clr = de_bgr555_to_888(clr);
215 }
216 else {
217 n = de_get_bits_symbol_lsb(c->infile, pg->fgbpp, pg->image_offset + 4*pg->width_in_words*j,
218 i_adj);
219 clr = DE_MAKE_OPAQUE(pg->pal[(int)n]);
220 }
221
222 de_bitmap_setpixel_rgba(img, i, j, clr);
223 }
224 }
225
226 if(pg->has_mask) {
227 de_dbg(c, "transparency mask at %"I64_FMT, pg->mask_offset);
228
229 if(pg->maskbpp<1 || pg->maskbpp>8) {
230 de_warn(c, "This type of transparency mask is not supported");
231 goto after_mask;
232 }
233
234 mask = de_bitmap_create(c, pg->num_fg_x_pixels_to_convert, pg->height, 1);
235 // Start with an opaque mask.
236 de_bitmap_rect(mask, 0, 0, mask->width, mask->height, DE_STOCKCOLOR_WHITE, 0);
237
238 for(j=0; j<pg->height; j++) {
239 for(i=0; i<pg->num_mask_x_pixels_to_convert; i++) {
240 i64 src_xpos, dst_xpos;
241 de_colorsample a = 255;
242
243 src_xpos = i + pg->x_idx_of_first_src_mask_pixel_to_convert;
244 dst_xpos = i + pg->mask_x_offset;
245
246 n = de_get_bits_symbol_lsb(c->infile, pg->maskbpp, pg->mask_offset + pg->mask_rowspan*j,
247 src_xpos);
248
249 if(pg->mask_type==MASK_TYPE_OLD || pg->mask_type==MASK_TYPE_NEW_1) {
250 if(n==0)
251 a = 0;
252 else
253 a = 255;
254 }
255 else if(pg->mask_type==MASK_TYPE_NEW_8) {
256 a = n;
257 }
258 de_bitmap_setpixel_gray(mask, dst_xpos, j, a);
259 }
260 }
261
262 de_bitmap_apply_mask(img, mask, 0);
263 }
264 after_mask:
265
266 de_bitmap_write_to_file_finfo(img, fi, 0);
267 de_bitmap_destroy(img);
268 if(mask) de_bitmap_destroy(mask);
269 }
270
271 static u32 average_color(u32 c1, u32 c2)
272 {
273 u8 a, r, g, b;
274 a = ((u32)DE_COLOR_A(c1) + DE_COLOR_A(c2))/2;
275 r = ((u32)DE_COLOR_R(c1) + DE_COLOR_R(c2))/2;
276 g = ((u32)DE_COLOR_G(c1) + DE_COLOR_G(c2))/2;
277 b = ((u32)DE_COLOR_B(c1) + DE_COLOR_B(c2))/2;
278 return DE_MAKE_RGBA(r,g,b,a);
279 }
280
281 static void do_setup_palette(deark *c, lctx *d, struct page_ctx *pg)
282 {
283 i64 k;
284 u32 clr1, clr2, clr3;
285
286 if(pg->fgbpp>8) {
287 return;
288 }
289
290 if(pg->has_custom_palette) {
291 de_dbg(c, "custom palette at %d, %d entries", (int)pg->custom_palette_pos,
292 (int)pg->custom_palette_ncolors);
293 }
294 de_dbg_indent(c, 1);
295
296 for(k=0; k<256; k++) {
297 if(pg->has_custom_palette) {
298 if(k<pg->custom_palette_ncolors) {
299 // Each palette entry has two colors, which are usually but not always
300 // the same.
301 // TODO: Figure out what to do if they are different. For now, we'll
302 // average them.
303 clr1 = dbuf_getRGB(c->infile, pg->custom_palette_pos + 8*k + 1, 0);
304 clr2 = dbuf_getRGB(c->infile, pg->custom_palette_pos + 8*k + 4 + 1, 0);
305 if(clr1==clr2) {
306 pg->pal[k] = clr1;
307 de_dbg_pal_entry(c, k, clr1);
308 }
309 else {
310 char tmps[64];
311
312 clr3 = average_color(clr1, clr2);
313 pg->pal[k] = clr3;
314 de_snprintf(tmps, sizeof(tmps), "(%3d,%3d,%3d),(%3d,%3d,%3d) "DE_CHAR_RIGHTARROW" ",
315 (int)DE_COLOR_R(clr1), (int)DE_COLOR_G(clr1), (int)DE_COLOR_B(clr1),
316 (int)DE_COLOR_R(clr2), (int)DE_COLOR_G(clr2), (int)DE_COLOR_B(clr2));
317 de_dbg_pal_entry2(c, k, clr3, tmps, NULL, NULL);
318 }
319 }
320 else {
321 pg->pal[k] = getpal256((int)k);
322 }
323 }
324 else if(pg->fgbpp==4 && k<16) {
325 pg->pal[k] = getpal16((int)k);
326 }
327 else if(pg->fgbpp==2 && k<4) {
328 pg->pal[k] = getpal4((int)k);
329 }
330 else if(pg->fgbpp==1 && k<2) {
331 pg->pal[k] = (k==0)?DE_STOCKCOLOR_WHITE:DE_STOCKCOLOR_BLACK;
332 }
333 else {
334 pg->pal[k] = getpal256((int)k);
335 }
336 }
337
338 de_dbg_indent(c, -1);
339 }
340
341 static void read_sprite_name(deark *c, lctx *d, de_finfo *fi, i64 pos)
342 {
343 de_ucstring *s = NULL;
344 if(c->debug_level<1 && !c->filenames_from_file) return;
345
346 s = ucstring_create(c);
347 dbuf_read_to_ucstring(c->infile, pos, 12, s, DE_CONVFLAG_STOP_AT_NUL, DE_ENCODING_RISCOS);
348 de_dbg(c, "sprite name: \"%s\"", ucstring_getpsz(s));
349
350 if(c->filenames_from_file) {
351 de_finfo_set_name_from_ucstring(c, fi, s, 0);
352 }
353
354 ucstring_destroy(s);
355 }
356
357 static void do_sprite(deark *c, lctx *d, i64 index,
358 i64 pos1, i64 len)
359 {
360 i64 new_img_type;
361 de_finfo *fi = NULL;
362 int saved_indent_level;
363 struct page_ctx *pg = NULL;
364
365 de_dbg_indent_save(c, &saved_indent_level);
366 pg = de_malloc(c, sizeof(struct page_ctx));
367
368 de_dbg(c, "image header at %d", (int)pos1);
369 de_dbg_indent(c, 1);
370
371 // Name at pos 4, len=12
372 fi = de_finfo_create(c);
373
374 read_sprite_name(c, d, fi, pos1+4);
375
376 pg->width_in_words = de_getu32le(pos1+16) +1;
377 pg->height = de_getu32le(pos1+20) +1;
378 de_dbg(c, "width-in-words: %d, height: %d", (int)pg->width_in_words, (int)pg->height);
379
380 pg->first_bit = de_getu32le(pos1+24);
381 if(pg->first_bit>31) pg->first_bit=31;
382 pg->last_bit = de_getu32le(pos1+28);
383 if(pg->last_bit>31) pg->last_bit=31;
384 pg->image_offset = de_getu32le(pos1+32) + pos1;
385 pg->mask_offset = de_getu32le(pos1+36) + pos1;
386 pg->has_mask = (pg->mask_offset != pg->image_offset);
387 de_dbg(c, "first bit: %d, last bit: %d", (int)pg->first_bit, (int)pg->last_bit);
388 de_dbg(c, "image offset: %d, mask_offset: %d", (int)pg->image_offset, (int)pg->mask_offset);
389
390 pg->mode = (u32)de_getu32le(pos1+40);
391 de_dbg(c, "mode: 0x%08x", (unsigned int)pg->mode);
392
393 de_dbg_indent(c, 1);
394
395 new_img_type = (pg->mode&0x78000000U)>>27;
396 if(new_img_type==0)
397 de_dbg(c, "old format screen mode: %d", (int)pg->mode);
398 else
399 de_dbg(c, "new format image type: %d", (int)new_img_type);
400
401 if(new_img_type==0) {
402 // old format
403 int x;
404
405 for(x=0; old_mode_info_arr[x].mode<1000; x++) {
406 if(pg->mode == old_mode_info_arr[x].mode) {
407 pg->fgbpp = (i64)old_mode_info_arr[x].fgbpp;
408 pg->xdpi = (i64)old_mode_info_arr[x].xdpi;
409 pg->ydpi = (i64)old_mode_info_arr[x].ydpi;
410 break;
411 }
412 }
413
414 if(pg->fgbpp==0) {
415 de_err(c, "Screen mode %d not supported", (int)pg->mode);
416 goto done;
417 }
418
419 if(pg->fgbpp>8 && pg->has_mask) {
420 de_err(c, "Transparency not supported for this image format");
421 goto done;
422 }
423
424 if(pg->has_mask) {
425 pg->mask_type = MASK_TYPE_OLD;
426 pg->mask_rowspan = 4*pg->width_in_words;
427 pg->maskbpp = pg->fgbpp;
428 de_dbg(c, "mask type: old");
429 }
430 }
431 else {
432 // new format
433 pg->xdpi = (pg->mode&0x07ffc000)>>14;
434 pg->ydpi = (pg->mode&0x00003ffe)>>1;
435 de_dbg(c, "xdpi: %d, ydpi: %d", (int)pg->xdpi, (int)pg->ydpi);
436 switch(new_img_type) {
437 case 1:
438 pg->fgbpp = 1;
439 break;
440 case 2:
441 pg->fgbpp = 2;
442 break;
443 case 3:
444 pg->fgbpp = 4;
445 break;
446 case 4:
447 pg->fgbpp = 8;
448 break;
449 case 5:
450 pg->fgbpp = 16;
451 break;
452 case 6:
453 pg->fgbpp = 32;
454 break;
455 //case 7: 32bpp CMYK (TODO)
456 //case 8: 24bpp (TODO)
457 default:
458 de_err(c, "New format type %d not supported", (int)new_img_type);
459 goto done;
460 }
461
462 if(pg->has_mask) {
463 pg->mask_type = (pg->mode&0x80000000U) ? MASK_TYPE_NEW_8 : MASK_TYPE_NEW_1;
464 pg->maskbpp = 8;
465 de_dbg(c, "mask type: new - %s", pg->mask_type==MASK_TYPE_NEW_8 ? "alpha" : "binary");
466 }
467 }
468
469 de_dbg(c, "foreground bits/pixel: %d", (int)pg->fgbpp);
470
471 de_dbg_indent(c, -1);
472
473 pg->width = ((pg->width_in_words-1) * 4 * 8 + (pg->last_bit+1)) / pg->fgbpp;
474 pg->num_padding_pixels_at_start_of_row = pg->first_bit / pg->fgbpp;
475 pg->width -= pg->num_padding_pixels_at_start_of_row;
476 de_dbg(c, "calculated width: %d", (int)pg->width);
477
478 if(!de_good_image_dimensions(c, pg->width, pg->height)) goto done;
479
480 if(pg->mask_type==MASK_TYPE_NEW_1 || pg->mask_type==MASK_TYPE_NEW_8) {
481 if(pg->num_padding_pixels_at_start_of_row>0) {
482 de_warn(c, "This image has a new-style transparency mask, and a "
483 "nonzero \"first bit\" field. This combination might not be "
484 "handled correctly.");
485 }
486 pg->mask_rowspan = ((pg->width+31)/32)*4;
487 }
488
489 de_dbg_indent(c, -1);
490
491 pg->custom_palette_pos = pos1 + 44;
492 if(pg->image_offset >= pg->custom_palette_pos+8 && pg->fgbpp<=8) {
493 pg->has_custom_palette = 1;
494 pg->custom_palette_ncolors = (pg->image_offset - (pos1+44))/8;
495 if(pg->custom_palette_ncolors>256) pg->custom_palette_ncolors=256;
496 }
497
498 do_setup_palette(c, d, pg);
499
500 do_image(c, d, pg, fi);
501 done:
502 de_dbg_indent_restore(c, saved_indent_level);
503 de_finfo_destroy(c, fi);
504 de_free(c, pg);
505 }
506
507 static void de_run_rosprite(deark *c, de_module_params *mparams)
508 {
509 lctx *d = NULL;
510 i64 pos;
511 i64 sprite_size;
512 i64 first_sprite_offset;
513 i64 implied_file_size;
514 i64 k;
515
516 d = de_malloc(c, sizeof(lctx));
517
518 pos = 0;
519
520 d->num_images = de_getu32le(pos);
521 de_dbg(c, "number of images: %d", (int)d->num_images);
522 first_sprite_offset = de_getu32le(pos+4) - 4;
523 de_dbg(c, "first sprite offset: %d", (int)first_sprite_offset);
524 implied_file_size = de_getu32le(pos+8) - 4;
525 de_dbg(c, "reported file size: %d", (int)implied_file_size);
526 if(implied_file_size != c->infile->len) {
527 de_warn(c, "The \"first free word\" field implies the file size is %d, but it "
528 "is actually %d. This may not be a sprite file.",
529 (int)implied_file_size, (int)c->infile->len);
530 }
531
532 pos = 12;
533 for(k=0; k<d->num_images; k++) {
534 if(pos>=c->infile->len) break;
535 sprite_size = de_getu32le(pos);
536 de_dbg(c, "image #%d at %d, size=%d", (int)k, (int)pos, (int)sprite_size);
537 if(sprite_size<1) break;
538 de_dbg_indent(c, 1);
539 do_sprite(c, d, k, pos, sprite_size);
540 de_dbg_indent(c, -1);
541 pos += sprite_size;
542 }
543
544 de_free(c, d);
545 }
546
547 static int de_identify_rosprite(deark *c)
548 {
549 i64 h0, h1, h2;
550 h0 = de_getu32le(0);
551 h1 = de_getu32le(4);
552 h2 = de_getu32le(8);
553
554 if(h0<1 || h0>10000) return 0;
555 if(h1-4<12) return 0;
556 if(h1-4 >= c->infile->len) return 0;
557 if(h2-4 != c->infile->len) return 0;
558
559 return 80;
560 }
561
562 void de_module_rosprite(deark *c, struct deark_module_info *mi)
563 {
564 mi->id = "rosprite";
565 mi->desc = "RISC OS Sprite, a.k.a. Acorn Sprite";
566 mi->run_fn = de_run_rosprite;
567 mi->identify_fn = de_identify_rosprite;
568 }
Deark is a portable command-line utility that can decode certain types of files.