?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
delint for clang
[AROS.git] / tools / ilbmtoicon / ilbmtoicon.c
blobd8ee3645e8c4105ca8aa3fe6334de2847f3fa3da
1 /*
2 Copyright © 1995-2013, The AROS Development Team. All rights reserved.
3 $Id$
4
5 Desc: Tool to convert IFF ILBM images into Amiga icon file.
6
7 Lang: English
8
9 */
10
11 #define D(x)
12
13 /****************************************************************************************/
14
15 #include <stdio.h>
16 #include <string.h>
17 #include <stdlib.h>
18 #include <ctype.h>
19
20 #include <png.h>
21 #include <zlib.h>
22
23 /****************************************************************************************/
24
25 #define TRUE ~0
26 #define FALSE 0
27
28 #define MAKE_ID(a,b,c,d) (((a)<<24) | ((b)<<16) | ((c)<<8) | ((d)))
29
30 #define ID_FORM MAKE_ID('F','O','R','M')
31 #define ID_ILBM MAKE_ID('I','L','B','M')
32 #define ID_CMAP MAKE_ID('C','M','A','P')
33 #define ID_BODY MAKE_ID('B','O','D','Y')
34 #define ID_BMHD MAKE_ID('B','M','H','D')
35
36 #define ID_ICON MAKE_ID('I','C','O','N')
37 #define ID_FACE MAKE_ID('F','A','C','E')
38 #define ID_IMAG MAKE_ID('I','M','A','G')
39 #define ID_PNG MAKE_ID('p','n','g',' ')
40 #define ID_ARGB MAKE_ID('A','R','G','B')
41
42 #define CMP_NONE 0
43 #define CMP_BYTERUN1 1
44
45 #define MSK_HASMASK 1
46 #define MSK_HASTRANS 2
47
48 /****************************************************************************************/
49
50 /* For this tool it does not really matter if the following types
51 have a bigger sizeof() than on Amiga */
52
53 #ifndef __AROS__
54 typedef void *APTR;
55 typedef unsigned long ULONG;
56 typedef long LONG;
57 typedef unsigned short UWORD;
58 typedef short WORD;
59 typedef short BOOL;
60 typedef unsigned char UBYTE;
61 #else
62 #include <exec/types.h>
63 #endif
64
65 /****************************************************************************************/
66
67 struct BitMapHeader
68 {
69 UWORD bmh_Width;
70 UWORD bmh_Height;
71 WORD bmh_Left;
72 WORD bmh_Top;
73 UBYTE bmh_Depth;
74 UBYTE bmh_Masking;
75 UBYTE bmh_Compression;
76 UBYTE bmh_Pad;
77 UWORD bmh_Transparent;
78 UBYTE bmh_XAspect;
79 UBYTE bmh_YAspect;
80 WORD bmh_PageWidth;
81 WORD bmh_PageHeight;
82 };
83
84 /****************************************************************************************/
85
86 struct ILBMImage
87 {
88 struct BitMapHeader bmh;
89 struct BitMapHeader planarbmh;
90 unsigned char *planarbuffer, *chunkybuffer;
91 LONG cmapentries, bpr, totdepth;
92 UBYTE rgb[256][3];
93 UBYTE remaptable[256];
94 APTR png;
95 ULONG png_size;
96 APTR argb;
97 ULONG argb_size;
98 };
99
100 /****************************************************************************************/
101
102 struct Palette
103 {
104 UWORD numentries;
105 UBYTE rgb[][3];
106 };
107
108 /****************************************************************************************/
109
110 struct Palette std4colpal =
111 {
112 4,
113 {
114 {0x95, 0x95, 0x95}, /* Gray (and transparent!) */
115 {0x00, 0x00, 0x00}, /* Black */
116 {0xFF, 0xFF, 0xFF}, /* White */
117 {0x3b, 0x67, 0xa2} /* Blue */
118 }
119 };
120
121 /****************************************************************************************/
122
123 struct Palette magicwb8colpal =
124 {
125 8,
126 {
127 {0x95, 0x95, 0x95}, /* Gray (and transparent!) */
128 {0x00, 0x00, 0x00}, /* Black */
129 {0xFF, 0xFF, 0xFF}, /* White */
130 {0x3b, 0x67, 0xa2}, /* Blue */
131 {0x7b, 0x7b, 0x7b}, /* Dk. Gray */
132 {0xaf, 0xaf, 0xaf}, /* Lt. Gray */
133 {0xaa, 0x90, 0x7c}, /* Brown */
134 {0xff, 0xa9, 0x97} /* Pink */
135 }
136 };
137
138 /****************************************************************************************/
139
140 struct Palette scalos16colpal =
141 {
142 16,
143 {
144 { 0x9c, 0x9c, 0x9c }, /* 0 - Gray */
145 { 0x00, 0x00, 0x00 }, /* 1 - Black */
146 { 0xFF, 0xFF, 0xFF }, /* 2 - White */
147 { 0x3a, 0x3a, 0xd7 }, /* 3 - Blue */
148 { 0x75, 0x75, 0x75 }, /* 4 - Med. Gray */
149 { 0xc4, 0xc4, 0xc4 }, /* 5 - Lt. Gray */
150 { 0xd7, 0xb0, 0x75 }, /* 6 - Peach */
151 { 0xeb, 0x62, 0x9c }, /* 7 - Pink */
152 { 0x13, 0x75, 0x27 }, /* 8 - Dk. Green */
153 { 0x75, 0x3a, 0x00 }, /* 9 - Brown */
154 { 0xff, 0xd7, 0x13 }, /* 10 - Yellow */
155 { 0x3a, 0x3a, 0x3a }, /* 11 - Dk. Gray */
156 { 0xc4, 0x13, 0x27 }, /* 12 - Red */
157 { 0x27, 0xb0, 0x3a }, /* 13 - Lt. Green */
158 { 0x3a, 0x75, 0xff }, /* 14 - Lt. Blue */
159 { 0xd7, 0x75, 0x27 }, /* 15 - Orange */
160 }
161 };
162
163 /* Convert from DPI to Amiga 'ticks' resolution */
164 #define TPD_X(x) ((11*1280*100/104/(x)+5)/10)
165 #define TPD_Y(y) ((11*1024*100/78/(y)+5)/10)
166
167 /****************************************************************************************/
168
169 static char *filename, *outfilename, *infilename;
170 static unsigned char *filebuffer, *body;
171 static FILE *file, *outfile, *infile;
172 static long filesize, bodysize, bodysize_packed;
173 static long filepos;
174 static struct ILBMImage img1, img2;
175 static BOOL have_bmhd, have_cmap, have_body, is_png;
176
177 /* 'ticks' per dot, corresponding to ~72dpi */
178 static ULONG tpdX = TPD_X(72), tpdY = TPD_Y(72);
179 static char *image1option;
180 static char *image2option;
181 static char *defaulttooloption;
182 static char *drawerdataoption;
183 static char **tooltypesoption;
184 static LONG typeoption = 3; /* WBTOOL */
185 static LONG iconleftoption = 0x80000000; /* NO_ICON_POSITION */
186 static LONG icontopoption = 0x80000000; /* NO_ICON_POSITION */
187 static LONG stackoption = 4096;
188 static LONG drawerleftoption = 50;
189 static LONG drawertopoption = 50;
190 static LONG drawerwidthoption = 400;
191 static LONG drawerheightoption = 100;
192 static LONG drawervleftoption = 0;
193 static LONG drawervtopoption = 0;
194 static LONG drawershowoption = 0;
195 static LONG drawershowasoption = 0;
196 static LONG transparentoption = -1;
197
198 static BOOL dualpng; /* png file contains second image */
199 static unsigned char *dualpngstart; /* address of 2nd image in filebuffer */
200 static BOOL nosavePNG; /* Don't save the original PNG data */
201 static BOOL nosaveARGB; /* Don't ARGB data */
202 static BOOL nosaveIFF; /* Don't save any IFF data */
203
204 /****************************************************************************************/
205
206 static void freeimage(struct ILBMImage *img)
207 {
208 if (img->chunkybuffer)
209 {
210 free(img->chunkybuffer);
211 img->chunkybuffer = NULL;
212 }
213
214 if (img->planarbuffer)
215 {
216 free(img->planarbuffer);
217 img->planarbuffer = NULL;
218 }
219
220 if (img->argb)
221 {
222 free(img->argb);
223 img->argb = NULL;
224 }
225
226 if (filebuffer)
227 {
228 free(filebuffer);
229 filebuffer = NULL;
230 }
231
232 if (file)
233 {
234 fclose(file);
235 file = NULL;
236 }
237
238 filepos = 0;
239 }
240
241 /****************************************************************************************/
242
243 static void cleanup(char *msg, int rc)
244 {
245 if (msg) fprintf(stderr, "ilbmtoicon: %s\n", msg);
246
247 freeimage(&img1);
248 freeimage(&img2);
249
250 if (outfile) fclose(outfile);
251 if (infile) fclose(infile);
252
253 exit(rc);
254 }
255
256 /****************************************************************************************/
257
258 static void getarguments(int argc, char **argv)
259 {
260 WORD i;
261
262 nosavePNG = 1;
263
264 for (; argc > 1 && argv[1][0] == '-'; argc--, argv++) {
265 if (strcmp(argv[1],"--png") == 0) {
266 nosavePNG = 0;
267 continue;
268 }
269 if (strcmp(argv[1],"--no-iff") == 0) {
270 nosaveIFF = 1;
271 continue;
272 }
273 if (strcmp(argv[1],"--no-argb") == 0) {
274 nosaveIFF = 1;
275 continue;
276 }
277 if (strcmp(argv[1],"--dpi") == 0) {
278 char *cp;
279 long dpiX, dpiY;
280 argc--;
281 argv++;
282 dpiX = strtol(argv[1], &cp, 0);
283 if (*cp == ':') {
284 cp++;
285 dpiY = strtol(cp, NULL, 0);
286 } else {
287 dpiY = dpiX;
288 }
289 tpdX = TPD_X(dpiX);
290 tpdY = TPD_Y(dpiY);
291 continue;
292 }
293 }
294
295
296 if ((argc != 4) && (argc != 5))
297 {
298 fprintf(stderr, "Wrong number of arguments\n");
299 cleanup("Usage: ilbmtoicon [--png] [--no-argb] [--no-iff] icondescription image1 [image2] filename", 1);
300 }
301
302 if (argc == 4)
303 {
304 infilename = argv[1];
305 image1option = argv[2];
306 outfilename = argv[3];
307 }
308 else if (argc == 5)
309 {
310 infilename = argv[1];
311 image1option = argv[2];
312 image2option = argv[3];
313 outfilename = argv[4];
314 }
315 }
316
317 /****************************************************************************************/
318
319 static char *skipblanks(char *s)
320 {
321 while ((*s == ' ') || (*s == '\t')) s++;
322
323 return s;
324 }
325
326 /****************************************************************************************/
327
328 static char *skipword(char *s)
329 {
330 while((*s != ' ') &&
331 (*s != '\t') &&
332 (*s != '\0') &&
333 (*s != '\n'))
334 {
335 s++;
336 }
337
338 return s;
339 }
340
341 /****************************************************************************************/
342
343 static char *checkquotes(char *s)
344 {
345 char *s2;
346 static char s3[256];
347 BOOL escaped = 0;
348 int i = 0;
349
350 if (*s != '"')
351 {
352 s2 = skipword(s);
353 *s2 = '\0';
354
355 return s;
356 }
357
358 s++;
359
360
361 while ((i < 256) && (s3[i] = *s))
362 {
363 if (!escaped)
364 {
365 if (*s == '\\')
366 {
367 escaped = !escaped;
368 i--;
369 }
370 else if (*s == '"')
371 break;
372 }
373 else
374 escaped = !escaped;
375 i++;
376 s++;
377 }
378 s3[i] = '\0';
379 s = s3;
380
381 return s;
382 }
383
384 /****************************************************************************************/
385
386 #define KEYWORD_STRING 0
387 #define KEYWORD_INTEGER 1
388 #define KEYWORD_STRINGARRAY 2
389 #define KEYWORD_CYCLE 3
390
391 #define MAX_ARRAY_SIZE 200
392
393 /****************************************************************************************/
394
395 struct cycle
396 {
397 char *keyword;
398 LONG value;
399 };
400
401 struct cycle typecycles[] =
402 {
403 {"DISK" , 1},
404 {"DRAWER" , 2},
405 {"TOOL" , 3},
406 {"PROJECT" , 4},
407 {"GARBAGE" , 5},
408 {"DEVICE" , 6},
409 {"KICK" , 7},
410 {"APPICON" , 8},
411 };
412
413 struct cycle showcycles[] =
414 {
415 {"DEFAULT" , 0},
416 {"ICONS" , 1},
417 {"ALL" , 2},
418 {NULL , 0}
419
420 };
421
422 struct cycle showascycles[] =
423 {
424 {"DEFAULT" , 0},
425 {"ICON" , 1},
426 {"TEXT_NAME", 2},
427 {"TEXT_DATE", 3},
428 {"TEXT_SIZE", 4},
429 {"TEXT_TYPE", 5},
430 {NULL , 0}
431
432 };
433
434
435 /****************************************************************************************/
436
437 struct keyword
438 {
439 WORD type;
440 char *keyword;
441 APTR store;
442 APTR extra;
443 }
444 keywordtable[] =
445 {
446 {KEYWORD_STRING , "DEFAULTTOOL" , &defaulttooloption , NULL },
447 {KEYWORD_STRING , "DRAWERDATA" , &drawerdataoption , NULL },
448 {KEYWORD_CYCLE , "TYPE" , &typeoption , typecycles },
449 {KEYWORD_STRINGARRAY, "TOOLTYPE" , &tooltypesoption , NULL },
450 {KEYWORD_INTEGER , "STACK" , &stackoption , NULL },
451 {KEYWORD_INTEGER , "ICONLEFTPOS" , &iconleftoption , NULL },
452 {KEYWORD_INTEGER , "ICONTOPPOS" , &icontopoption , NULL },
453 {KEYWORD_INTEGER , "DRAWERLEFTPOS" , &drawerleftoption , NULL },
454 {KEYWORD_INTEGER , "DRAWERTOPPOS" , &drawertopoption , NULL },
455 {KEYWORD_INTEGER , "DRAWERWIDTH" , &drawerwidthoption , NULL },
456 {KEYWORD_INTEGER , "DRAWERHEIGHT" , &drawerheightoption , NULL },
457 {KEYWORD_INTEGER , "DRAWERVIEWLEFT" , &drawervleftoption , NULL },
458 {KEYWORD_INTEGER , "DRAWERVIEWTOP" , &drawervtopoption , NULL },
459 {KEYWORD_CYCLE , "DRAWERSHOW" , &drawershowoption , showcycles },
460 {KEYWORD_CYCLE , "DRAWERSHOWAS" , &drawershowoption , showascycles },
461 {KEYWORD_INTEGER , "TRANSPARENT" , &transparentoption , NULL },
462 {0 , NULL , NULL }
463 };
464
465
466 /****************************************************************************************/
467
468 static void handleoption(char *keyword, char *keyvalue)
469 {
470 struct keyword *kw;
471 struct cycle *cy;
472
473 D(printf("Keyword %s, value %s\n", keyword, keyvalue));
474
475 for(kw = keywordtable; kw->keyword; kw++)
476 {
477 if (strcasecmp(kw->keyword, keyword) == 0)
478 {
479 switch(kw->type)
480 {
481 case KEYWORD_STRING:
482 *(char **)kw->store = strdup(keyvalue);
483 if (!(*(char **)kw->store)) cleanup("Out of memory!", 1);
484 break;
485
486 case KEYWORD_INTEGER:
487 *(LONG *)kw->store = strtol(keyvalue, 0, 0);
488 break;
489
490 case KEYWORD_CYCLE:
491 for(cy = (struct cycle *)kw->extra; cy->keyword; cy++)
492 {
493 if (strcasecmp(keyvalue, cy->keyword) == 0)
494 {
495 *(LONG *)kw->store = cy->value;
496 break;
497 }
498 }
499 break;
500
501 case KEYWORD_STRINGARRAY:
502 if (!(*(char ***)kw->store))
503 {
504 *(char ***)kw->store = (char **)malloc(MAX_ARRAY_SIZE * sizeof(char *));
505 if (!(*(char ***)kw->store)) cleanup("Out of memory!", 1);
506
507 memset(*(char ***)kw->store, 0, MAX_ARRAY_SIZE * sizeof(char *));
508 }
509
510 {
511 char *dupvalue;
512 char **strarray = *(char ***)kw->store;
513 WORD i = 0;
514
515 dupvalue = strdup(keyvalue);
516 if (!dupvalue) cleanup("Out of memory!", 1);
517
518 while(*strarray)
519 {
520 strarray++;
521 i++;
522 }
523
524 if (i >= MAX_ARRAY_SIZE - 1) cleanup("Array overflow!", 1);
525
526 *strarray = dupvalue;
527 }
528
529 } /* switch(kw->type) */
530
531 break;
532
533 } /* if (strcasecmp(kw->keyword, keyword) == 0) */
534
535 } /* for(kw = keywordtable; kw->keyword; kw++) */
536
537 }
538
539 /****************************************************************************************/
540
541 static void parseline(char *s)
542 {
543 char *keyword;
544 char *keyvalue = NULL;
545
546 s = skipblanks(s);
547
548 if (*s == '#') return;
549 if (*s == ';') return;
550
551 keyword = s;
552
553 s = skipword(s);
554 if (*s == '\0') return;
555
556 *s = '\0';
557 s = skipblanks(s + 1);
558
559 if (*s == '=') s = skipblanks(s + 1);
560 if (*s == '\0') return;
561
562 keyvalue = checkquotes(s);
563
564 handleoption(keyword, keyvalue);
565 }
566
567 /****************************************************************************************/
568
569 static void parseiconsource(void)
570 {
571 char s[256];
572
573 infile = fopen(infilename, "r");
574 if (infile)
575 {
576 while(fgets(s, sizeof(s), infile))
577 {
578 D(printf("Read line: %s\n", s));
579 parseline(s);
580 }
581
582 fclose(infile);
583 infile = 0;
584 }
585 }
586
587 /****************************************************************************************/
588
589 static void showoptions(void)
590 {
591 char **strarray;
592
593 printf("image1: %s\n", image1option ? image1option : "(NULL)");
594 printf("image2: %s\n", image2option ? image2option : "(NULL)");
595 printf("type: %ld\n", typeoption);
596
597 strarray = tooltypesoption;
598 if (strarray)
599 {
600 printf("tooltypes:\n");
601 while(*strarray)
602 {
603 printf(" %s\n", *strarray++);
604 }
605 }
606 }
607
608 /****************************************************************************************/
609
610 static ULONG getlong(void)
611 {
612 ULONG ret;
613
614 if (filepos > filesize - 4) cleanup("Tried to read over file end!", 1);
615
616 ret = filebuffer[filepos++] * 0x1000000;
617 ret += filebuffer[filepos++] * 0x10000;
618 ret += filebuffer[filepos++] * 0x100;
619 ret += filebuffer[filepos++];
620
621 return ret;
622 }
623
624 /****************************************************************************************/
625
626 static UWORD getword(void)
627 {
628 UWORD ret;
629
630 if (filepos > filesize - 2) cleanup("Tried to read over file end!", 1);
631
632 ret = filebuffer[filepos++] * 0x100;
633 ret += filebuffer[filepos++];
634
635 return ret;
636 }
637
638 /****************************************************************************************/
639
640 static UBYTE getbyte(void)
641 {
642 ULONG ret;
643
644 if (filepos > filesize - 1) cleanup("Tried to read over file end!", 1);
645 ret = filebuffer[filepos++];
646
647 return ret;
648 }
649
650 /****************************************************************************************/
651
652 static void skipbytes(ULONG howmany)
653 {
654 filepos += howmany;
655 }
656
657 /****************************************************************************************/
658
659 static void openimage(struct ILBMImage *img)
660 {
661 file = fopen(filename, "rb");
662 if (!file) cleanup("Can't open file!", 1);
663
664 fseek(file, 0, SEEK_END);
665 filesize = ftell(file);
666
667 if (filesize < 12) cleanup("Bad file size!", 1);
668
669 //fprintf(stderr, "Filesize is %d\n", filesize);
670
671 fseek(file, 0, SEEK_SET);
672
673 filebuffer = malloc(filesize + 10);
674 if (!filebuffer) cleanup("Memory allocation for file buffer failed!", 1);
675
676 if (fread(filebuffer, 1, filesize, file) != filesize)
677 cleanup("Error reading file!", 1);
678
679 fclose(file); file = NULL;
680 }
681
682 /****************************************************************************************/
683
684 static void checkimage(struct ILBMImage *img)
685 {
686 static UBYTE pngsig[8] = {137, 80, 78, 71, 13, 10, 26, 10};
687
688 ULONG id;
689 ULONG size;
690
691 if (dualpng) {
692 img->png = dualpngstart;
693 img->png_size = filesize - (dualpngstart - filebuffer);
694 return;
695 }
696
697 if (memcmp(filebuffer, pngsig, 8) == 0)
698 {
699 is_png = 1;
700 img->png = filebuffer;
701
702 /* search for second image */
703 for
704 (
705 dualpngstart = filebuffer + 8 ;
706 dualpngstart < filebuffer + filesize - 8 ;
707 dualpngstart++
708 )
709 {
710 if (memcmp(dualpngstart, pngsig, 8) == 0)
711 {
712 dualpng = 1;
713 break;
714 }
715 }
716 if (dualpng)
717 img->png_size = dualpngstart - filebuffer;
718 else
719 img->png_size = filesize;
720 }
721 else if (is_png == 0)
722 {
723 id = getlong();
724 if (id != ID_FORM) cleanup("File is not an IFF file!", 1);
725
726 size = getlong();
727 if (size != filesize - 8) cleanup("File is IFF, but has bad size in IFF header!", 1);
728
729 id = getlong();
730 if (id != ID_ILBM) cleanup("File is IFF, but not of type ILBM!", 1);
731 }
732 else if (is_png == 1)
733 {
734 cleanup("Second image must be a PNG image, too!", 1);
735 }
736
737 }
738
739 /****************************************************************************************/
740
741 static void my_read_fn(png_structp png_ptr, png_bytep data, png_size_t length)
742 {
743 png_bytep *pdata = png_get_io_ptr(png_ptr);
744
745 if (*pdata-filebuffer >= filesize)
746 png_error(png_ptr, "Read past end of file");
747
748 memcpy(data, *pdata, length);
749 *pdata += length;
750 }
751
752 static UBYTE findcolor(struct Palette *pal, ULONG r, ULONG g, ULONG b, BOOL notrans);
753
754 static void loadpng(struct ILBMImage *img, struct Palette *pal)
755 {
756 png_structp png_ptr;
757 png_infop info_ptr, end_info;
758 png_bytep fpos, *row_pointers;
759 UBYTE *chunkrow;
760 UWORD width, height;
761 int x, y;
762
763 if (png_sig_cmp(img->png, 0, img->png_size) != 0)
764 cleanup("I thought it was a PNG, but I was wrong.", 1);
765
766 png_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING,
767 0, /* error ptr */
768 0,
769 0);
770 if (!png_ptr)
771 cleanup("png_create_read_struct() failed", 1);
772
773 info_ptr = png_create_info_struct(png_ptr);
774 if (!info_ptr) {
775 png_destroy_read_struct(&png_ptr, NULL, NULL);
776 cleanup("png_create_info_struct() failed", 1);
777 }
778
779 end_info = png_create_info_struct(png_ptr);
780 if (!end_info) {
781 png_destroy_read_struct(&png_ptr, &info_ptr, NULL);
782 cleanup("png_create_info_struct() failed", 1);
783 }
784
785 fpos = img->png;
786 png_set_read_fn(png_ptr, &fpos, my_read_fn);
787
788 if (setjmp(png_jmpbuf(png_ptr))) {
789 png_destroy_read_struct(&png_ptr, &info_ptr, &end_info);
790 cleanup("png read failed", 1);
791 }
792
793 /* Read the PNG as RGBA */
794 png_set_add_alpha(png_ptr, 255, PNG_FILLER_AFTER);
795 png_read_png(png_ptr, info_ptr, PNG_TRANSFORM_EXPAND | PNG_TRANSFORM_STRIP_16, NULL);
796
797 row_pointers = png_get_rows(png_ptr, info_ptr);
798
799 width = png_get_image_width(png_ptr, info_ptr);
800 height = png_get_image_height(png_ptr, info_ptr);
801
802 img->bmh.bmh_Width = width;
803 img->bmh.bmh_Height = height;
804 img->bmh.bmh_Left = 0;
805 img->bmh.bmh_Top = 0;
806 img->bmh.bmh_Depth = 8;
807 img->bmh.bmh_Masking = MSK_HASTRANS;
808 img->bmh.bmh_Compression = CMP_NONE;
809 img->bmh.bmh_Pad = 0;
810 img->bmh.bmh_XAspect = 1;
811 img->bmh.bmh_YAspect = 1;
812 img->bmh.bmh_PageWidth = 320;
813 img->bmh.bmh_PageHeight = 200;
814
815 #if (0)
816 img->planarbmh;
817 #endif
818 img->bpr = ((img->bmh.bmh_Width + 15) & ~15) / 8;
819 img->totdepth = 0;
820
821 /* Transform the RGBA data into chunky */
822 img->cmapentries = pal->numentries;
823 memcpy(img->rgb, pal->rgb, sizeof(img->rgb[0])*pal->numentries);
824
825 img->chunkybuffer = malloc(width * height * sizeof(UBYTE));
826 if (!img->chunkybuffer)
827 cleanup("Can't allocate the chunky buffer", 1);
828
829 chunkrow = img->chunkybuffer;
830 img->argb_size = width * height * sizeof(UBYTE) * 4;
831 img->argb = malloc(img->argb_size);
832 if (!img->argb)
833 cleanup("Can't allocate the ARGB buffer", 1);
834
835 for (y = 0; y < height; y++) {
836 png_bytep row = row_pointers[y];
837 UBYTE *ap = img->argb + (width * sizeof(UBYTE) * 4) * y;
838 for (x = 0; x < width; x++, row += 4, ap += 4, chunkrow++) {
839 UBYTE r,g,b;
840
841 ap[0] = row[3];
842 ap[1] = row[0];
843 ap[2] = row[1];
844 ap[3] = row[2];
845
846 /* Opacity of 0? Use the transparency color */
847 if (row[3] == 0) {
848 if (transparentoption < 0)
849 transparentoption = 0;
850 *chunkrow = transparentoption;
851 } else {
852 r = row[0];
853 g = row[1];
854 b = row[2];
855
856 *chunkrow = findcolor(pal, r, g, b, TRUE);
857 }
858 }
859 }
860
861 img->bmh.bmh_Transparent = transparentoption;
862
863 png_destroy_read_struct(&png_ptr, &info_ptr, &end_info);
864 }
865
866
867 /****************************************************************************************/
868
869 static void scanimage(struct ILBMImage *img)
870 {
871 WORD i;
872
873 have_bmhd = 0;
874 have_cmap = 0;
875 have_body = 0;
876
877 if (img->png) {
878 /* Load the PNG, using the Scalos 16-color pallette,
879 * into the Chunky buffer.
880 */
881 loadpng(img, &scalos16colpal);
882 return;
883 }
884
885 for(;;)
886 {
887 ULONG id;
888 ULONG size;
889
890 id = getlong();
891 size = getlong();
892
893 //fprintf(stderr, "Chunk: %c%c%c%c Size: %d\n", id >> 24, id >> 16, id >> 8, id, size);
894
895 switch(id)
896 {
897 case ID_BMHD:
898 if (size != 20) cleanup("Bad BMHD chunk size!", 1);
899
900 img->bmh.bmh_Width = getword();
901 img->bmh.bmh_Height = getword();
902 img->bmh.bmh_Left = (WORD)getword();
903 img->bmh.bmh_Top = (WORD)getword();
904 img->bmh.bmh_Depth = getbyte();
905 img->bmh.bmh_Masking = getbyte();
906 img->bmh.bmh_Compression = getbyte();
907 img->bmh.bmh_Pad = getbyte();
908 img->bmh.bmh_Transparent = getword();
909 img->bmh.bmh_XAspect = getbyte();
910 img->bmh.bmh_YAspect = getbyte();
911 img->bmh.bmh_PageWidth = (WORD)getword();
912 img->bmh.bmh_PageHeight = (WORD)getword();
913
914 if (img->bmh.bmh_Depth > 8) cleanup("ILBM file has too many colors!", 1);
915 if ((img->bmh.bmh_Compression != CMP_NONE) && (img->bmh.bmh_Compression != CMP_BYTERUN1)) cleanup("Compression method unsupported!", 1);
916
917 have_bmhd = 1;
918
919 img->totdepth = img->bmh.bmh_Depth + ((img->bmh.bmh_Masking == MSK_HASMASK) ? 1 : 0);
920
921 img->bpr = ((img->bmh.bmh_Width + 15) & ~15) / 8;
922
923 /*fprintf(stderr, "BMHD: %d x %d x %d (%d)\n", img->bmh.bmh_Width,
924 img->bmh.bmh_Height,
925 img->bmh.bmh_Depth,
926 img->totdepth);*/
927 img->planarbmh = img->bmh;
928 break;
929
930 case ID_CMAP:
931 if (!have_bmhd) cleanup("CMAP chunk before BMHD chunk (or no BMHD chunk at all!", 1);
932
933 img->cmapentries = size / 3;
934 if (size & 1) size++;
935
936 if ((img->cmapentries < 2) || (img->cmapentries > 256)) cleanup("CMAP chunk has bad number of entries!", 1);
937
938 for(i = 0; i < img->cmapentries; i++)
939 {
940 img->rgb[i][0] = getbyte();
941 img->rgb[i][1] = getbyte();
942 img->rgb[i][2] = getbyte();
943 size -= 3;
944 }
945
946 skipbytes(size);
947
948 have_cmap = 1;
949
950 break;
951
952 case ID_BODY:
953 if (!have_bmhd) cleanup("BODY chunk before BMHD chunk (or no BMHD chunk at all!", 1);
954 body = &filebuffer[filepos];
955 bodysize = size;
956
957 if (img->bmh.bmh_Compression == CMP_NONE)
958 {
959 LONG shouldbesize = img->totdepth * img->bpr * img->bmh.bmh_Height;
960 if (bodysize != shouldbesize) cleanup("BODY chunk size seems to be wrong!", 1);
961 }
962
963 have_body = 1;
964 /* Fall through */
965
966 default:
967 if (size & 1) size++;
968 skipbytes(size);
969 break;
970 }
971
972 if (filepos == filesize) break;
973 if (have_bmhd && have_body && have_cmap) break;
974 }
975
976 if (!have_bmhd) cleanup("BMHD chunk missing!", 1);
977 if (!have_body) cleanup("BODY chunk missing!", 1);
978 }
979
980 /****************************************************************************************/
981
982 static unsigned char *unpack_byterun1(unsigned char *source, unsigned char *dest, LONG unpackedsize)
983 {
984 unsigned char r;
985 signed char c;
986
987 for(;;)
988 {
989 c = (signed char)(*source++);
990 if (c >= 0)
991 {
992 while(c-- >= 0)
993 {
994 *dest++ = *source++;
995 if (--unpackedsize <= 0) return source;
996 }
997 }
998 else if (c != -128)
999 {
1000 c = -c;
1001 r = *source++;
1002
1003 while(c-- >= 0)
1004 {
1005 *dest++ = r;
1006 if (--unpackedsize <= 0) return source;
1007 }
1008 }
1009 }
1010
1011 }
1012
1013 /****************************************************************************************/
1014
1015 static BOOL norm1(LONG count, unsigned char **source_backup,
1016 unsigned char **dest, LONG *checksize)
1017 {
1018 //if (count >= 0) fprintf(stderr, "XX: non packable %d\n",count);
1019
1020 while(count >= 0)
1021 {
1022 LONG step = count;
1023
1024 if (step > 127) step = 127;
1025
1026 *checksize -= step;
1027 *checksize -= 2;
1028
1029 if (*checksize <= 0) return 0;
1030
1031 count -= step;
1032
1033 *(*dest)++ = step;
1034
1035
1036 while(step-- >= 0)
1037 {
1038 *(*dest)++ = *(*source_backup)++;
1039 }
1040
1041 count--;
1042
1043 }
1044
1045 return 1;
1046 }
1047
1048 static BOOL copy1(unsigned char r, LONG count, unsigned char **dest, LONG *checksize)
1049 {
1050 //if (count >= 1) fprintf(stderr, "XX: repeat %02x x %d\n", r, count);
1051
1052 while(--count >= 0)
1053 {
1054 LONG step = count;
1055
1056 if (step > 127) step = 127;
1057
1058 count -= step;
1059 step = -step;
1060 *checksize -= 2;
1061 if (*checksize <= 0) return 0;
1062
1063 *(*dest)++ = (unsigned char)step;
1064 *(*dest)++ = r;
1065 }
1066
1067 return 1;
1068 }
1069
1070 static BOOL pack_byterun1(unsigned char *source, unsigned char *dest,
1071 LONG size, LONG check_size, LONG *packsize)
1072 {
1073 unsigned char *source_backup, *dest_backup;
1074 LONG samebytes_counter, samebytes, count;
1075 LONG checksize = check_size;
1076 unsigned char oldbyte, actbyte;
1077
1078 if (checksize < 0) checksize = 0x7FFFFFFF;
1079
1080 oldbyte = *source;
1081 samebytes_counter = 0;
1082 source_backup = source;
1083 dest_backup = dest;
1084
1085 for(;;)
1086 {
1087 //fprintf(stderr, "size = %d. checksize = %d\n", size, checksize);
1088 if (--size < 0) break;
1089 actbyte = *source++;
1090 if (actbyte == oldbyte)
1091 {
1092 samebytes_counter++;
1093 continue;
1094 }
1095
1096 oldbyte = actbyte;
1097
1098 samebytes = samebytes_counter;
1099 samebytes_counter = 1;
1100
1101 if (samebytes < 3) continue;
1102
1103 count = (LONG)(source - source_backup - samebytes - 2);
1104 if (!norm1(count, &source_backup, &dest, &checksize)) return 0;
1105
1106 if (!copy1(source[-2], samebytes, &dest, &checksize)) return 0;
1107
1108 source_backup = source - 1;
1109 }
1110 //fprintf(stderr, "done\n");
1111
1112 if (samebytes_counter >= 3)
1113 {
1114 samebytes = samebytes_counter;
1115 count = (LONG)(source - source_backup - samebytes - 1);
1116 if (!norm1(count, &source_backup, &dest, &checksize)) return 0;
1117 if (!copy1(source[-2], samebytes, &dest, &checksize)) return 0;
1118 }
1119 else
1120 {
1121 count = (LONG)(source - source_backup - 1);
1122 if (!norm1(count, &source_backup, &dest, &checksize)) return 0;
1123 }
1124 //fprintf(stderr, "realdone\n");
1125
1126 if (packsize) *packsize = (LONG)(dest - dest_backup);
1127
1128 return 1;
1129 }
1130
1131 /****************************************************************************************/
1132
1133 static void p2c(unsigned char *source, unsigned char *dest, LONG width, LONG height,
1134 LONG totplanes, LONG wantplanes, LONG chunkybpr)
1135 {
1136 LONG alignedwidth, x, y, p, bpr, bpl;
1137
1138 alignedwidth = (width + 15) & ~15;
1139 bpr = alignedwidth / 8;
1140 bpl = bpr * totplanes;
1141
1142 for(y = 0; y < height; y++)
1143 {
1144 for(x = 0; x < width; x++)
1145 {
1146 LONG mask = 0x80 >> (x & 7);
1147 LONG offset = x / 8;
1148 unsigned char chunkypix = 0;
1149
1150 for(p = 0; p < wantplanes; p++)
1151 {
1152 if (source[p * bpr + offset] & mask) chunkypix |= (1 << p);
1153 }
1154 dest[x] = chunkypix;
1155 }
1156
1157 source += bpl;
1158 dest += chunkybpr;
1159 }
1160
1161
1162 }
1163
1164 /****************************************************************************************/
1165
1166 static void c2p(unsigned char *source, unsigned char *dest, LONG width, LONG height, LONG planes)
1167 {
1168 LONG alignedwidth, x, y, p, bpr, bpl;
1169
1170 alignedwidth = (width + 15) & ~15;
1171 bpr = alignedwidth / 8;
1172 bpl = bpr * planes;
1173
1174 for(y = 0; y < height; y++)
1175 {
1176 for(x = 0; x < width; x++)
1177 {
1178 LONG mask = 0x80 >> (x & 7);
1179 LONG offset = x / 8;
1180 unsigned char chunkypix = source[x];
1181
1182 for(p = 0; p < planes; p++)
1183 {
1184 if (chunkypix & (1 << p))
1185 dest[p * bpr + offset] |= mask;
1186 else
1187 dest[p * bpr + offset] &= ~mask;
1188 }
1189 }
1190
1191 source += width;
1192 dest += bpl;
1193 }
1194
1195 }
1196
1197 /****************************************************************************************/
1198
1199 static void convertbody(struct ILBMImage *img)
1200 {
1201 LONG unpackedsize = img->bpr * img->bmh.bmh_Height * img->totdepth;
1202
1203 if (is_png)
1204 return;
1205
1206 img->planarbuffer = malloc(unpackedsize);
1207 if (!img->planarbuffer) cleanup("Memory allocation for planar buffer failed!", 1);
1208
1209 if (img->bmh.bmh_Compression == CMP_NONE)
1210 {
1211 memcpy(img->planarbuffer, body, unpackedsize);
1212 }
1213 else
1214 {
1215 unpack_byterun1(body, img->planarbuffer, unpackedsize);
1216 }
1217
1218 img->chunkybuffer = malloc(img->bmh.bmh_Width * img->bmh.bmh_Height);
1219 if (!img->chunkybuffer) cleanup("Memory allocation for chunky buffer failed!", 1);
1220
1221 p2c(img->planarbuffer,
1222 img->chunkybuffer,
1223 img->bmh.bmh_Width,
1224 img->bmh.bmh_Height,
1225 img->totdepth,
1226 img->bmh.bmh_Depth,
1227 img->bmh.bmh_Width);
1228 }
1229
1230 /****************************************************************************************/
1231
1232 static UBYTE findcolor(struct Palette *pal, ULONG r, ULONG g, ULONG b, BOOL notrans)
1233 {
1234 ULONG dist, bestdist = 0xFFFFFFFF;
1235 UBYTE i, besti = 0;
1236
1237 for(i = 0; i < pal->numentries; i++)
1238 {
1239 LONG r1, g1, b1, r2, g2, b2, dr, dg, db;
1240
1241 if (notrans && i == transparentoption)
1242 continue;
1243
1244 r1 = (LONG)r;
1245 g1 = (LONG)g;
1246 b1 = (LONG)b;
1247
1248 r2 = (LONG)pal->rgb[i][0];
1249 g2 = (LONG)pal->rgb[i][1];
1250 b2 = (LONG)pal->rgb[i][2];
1251
1252 dr = r1 - r2;
1253 dg = g1 - g2;
1254 db = b1 - b2;
1255
1256 dist = (dr * dr) + (dg * dg) + (db * db);
1257 if (dist < bestdist)
1258 {
1259 bestdist = dist;
1260 besti = i;
1261 }
1262
1263 }
1264
1265 return besti;
1266 }
1267
1268 /****************************************************************************************/
1269
1270 static void remapplanar(struct ILBMImage *img, struct Palette *pal)
1271 {
1272 UBYTE *remapbuffer;
1273 LONG i, x, y, highestcol = 0, newdepth = 0;
1274
1275 remapbuffer = malloc(img->bmh.bmh_Width * img->bmh.bmh_Height);
1276 if (!remapbuffer) cleanup("Error allocating remap buffer!", 1);
1277
1278 for(i = 0; i < img->cmapentries; i++)
1279 {
1280 img->remaptable[i] = findcolor(pal, img->rgb[i][0], img->rgb[i][1], img->rgb[i][2], FALSE);
1281 }
1282
1283 for(i = 0; i < img->bmh.bmh_Width * img->bmh.bmh_Height; i++)
1284 {
1285 remapbuffer[i] = img->remaptable[img->chunkybuffer[i]];
1286
1287 if (remapbuffer[i] > highestcol)
1288 highestcol = remapbuffer[i];
1289 }
1290
1291 for(i = highestcol; i; i >>= 1) newdepth++;
1292 if (newdepth == 0) newdepth = 1;
1293
1294 if (newdepth > img->totdepth)
1295 {
1296 if (img->planarbuffer)
1297 free(img->planarbuffer);
1298
1299 img->planarbuffer = malloc(img->bpr * img->bmh.bmh_Height * newdepth);
1300 if (!img->planarbuffer)
1301 {
1302 free(remapbuffer);
1303 cleanup("Error re-allocating planar buffer!", 1);
1304 }
1305 }
1306
1307 img->planarbmh.bmh_Width = img->bmh.bmh_Width;
1308 img->planarbmh.bmh_Height= img->bmh.bmh_Height;
1309 img->planarbmh.bmh_Depth = newdepth;
1310
1311 memset(img->planarbuffer, 0, img->bpr * img->bmh.bmh_Height * newdepth);
1312
1313 c2p(remapbuffer, img->planarbuffer, img->bmh.bmh_Width, img->bmh.bmh_Height, newdepth);
1314
1315 free(remapbuffer);
1316 }
1317
1318 /****************************************************************************************/
1319
1320 static void loadimage(char *name, struct ILBMImage *img)
1321 {
1322 freeimage(img);
1323
1324 filename = name;
1325
1326 openimage(img);
1327 checkimage(img);
1328 scanimage(img);
1329 convertbody(img);
1330 }
1331
1332 /****************************************************************************************/
1333
1334 struct diskobject
1335 {
1336 UBYTE do_magic[2];
1337 UBYTE do_version[2];
1338 UBYTE do_gadget_nextgadget[4];
1339 UBYTE do_gadget_leftedge[2];
1340 UBYTE do_gadget_topedge[2];
1341 UBYTE do_gadget_width[2];
1342 UBYTE do_gadget_height[2];
1343 UBYTE do_gadget_flags[2];
1344 UBYTE do_gadget_activation[2];
1345 UBYTE do_gadget_gadgettype[2];
1346 UBYTE do_gadget_gadgetrender[4];
1347 UBYTE do_gadget_selectrender[4];
1348 UBYTE do_gadget_gadgettext[4];
1349 UBYTE do_gadget_mutualexclude[4];
1350 UBYTE do_gadget_specialinfo[4];
1351 UBYTE do_gadget_gadgetid[2];
1352 UBYTE do_gadget_userdata[4];
1353 UBYTE do_type;
1354 UBYTE do_pad;
1355 UBYTE do_defaulttool[4];
1356 UBYTE do_tooltypes[4];
1357 UBYTE do_currentx[4];
1358 UBYTE do_currenty[4];
1359 UBYTE do_drawerdata[4];
1360 UBYTE do_toolwindow[4];
1361 UBYTE do_stacksize[4];
1362 };
1363
1364 /****************************************************************************************/
1365
1366 struct olddrawerdata
1367 {
1368 UBYTE dd_newwindow_leftedge[2];
1369 UBYTE dd_newwindow_topedge[2];
1370 UBYTE dd_newwindow_width[2];
1371 UBYTE dd_newwindow_height[2];
1372 UBYTE dd_newwindow_detailpen;
1373 UBYTE dd_newwindow_blockpen;
1374 UBYTE dd_newwindow_idcmpflags[4];
1375 UBYTE dd_newwindow_flags[4];
1376 UBYTE dd_newwindow_firstgadget[4];
1377 UBYTE dd_newwindow_checkmark[4];
1378 UBYTE dd_newwindow_title[4];
1379 UBYTE dd_newwindow_screen[4];
1380 UBYTE dd_newwindow_bitmap[4];
1381 UBYTE dd_newwindow_minwidth[2];
1382 UBYTE dd_newwindow_minheight[2];
1383 UBYTE dd_newwindow_maxwidth[2];
1384 UBYTE dd_newwindow_maxheight[2];
1385 UBYTE dd_newwindow_type[2];
1386 UBYTE dd_currentx[4];
1387 UBYTE dd_currenty[4];
1388 };
1389
1390 /****************************************************************************************/
1391
1392 struct newdrawerdata
1393 {
1394 UBYTE dd_flags[4];
1395 UBYTE dd_viewmodes[2];
1396 };
1397
1398 /****************************************************************************************/
1399
1400 struct image
1401 {
1402 UBYTE leftedge[2];
1403 UBYTE topedge[2];
1404 UBYTE width[2];
1405 UBYTE height[2];
1406 UBYTE depth[2];
1407 UBYTE imagedata[4];
1408 UBYTE planepick;
1409 UBYTE planeonoff;
1410 UBYTE nextimage[4];
1411 };
1412
1413 /****************************************************************************************/
1414
1415 #define SET_BYTE(field,value) \
1416 ACT_STRUCT.field = value
1417
1418 #define SET_WORD(field, value) \
1419 ACT_STRUCT.field[0] = ((value) >> 8) & 0xFF; \
1420 ACT_STRUCT.field[1] = (value) & 0xFF;
1421
1422 #define SET_LONG(field,value) \
1423 ACT_STRUCT.field[0] = ((value) >> 24) & 0xFF; \
1424 ACT_STRUCT.field[1] = ((value) >> 16) & 0xFF; \
1425 ACT_STRUCT.field[2] = ((value) >> 8) & 0xFF; \
1426 ACT_STRUCT.field[3] = (value) & 0xFF;
1427
1428 #define BOOL_YES 0x2A2A2A2A
1429 #define BOOL_NO 0x00000000
1430
1431 static void writediskobject(void)
1432 {
1433 struct diskobject dobj;
1434
1435 if (typeoption == 2) /* DRAWER */
1436 {
1437 drawerdataoption = "YES";
1438 }
1439
1440 #define ACT_STRUCT dobj
1441
1442 SET_WORD(do_magic, 0xE310);
1443 SET_WORD(do_version, 1);
1444 SET_LONG(do_gadget_nextgadget, 0);
1445 SET_WORD(do_gadget_leftedge, 0);
1446 SET_WORD(do_gadget_topedge, 0);
1447 SET_WORD(do_gadget_width, img1.bmh.bmh_Width);
1448 SET_WORD(do_gadget_height, img1.bmh.bmh_Height);
1449
1450 if (image2option)
1451 {
1452 /* GFLG_GADGHIMAGE + GFLG_GADGIMAGE */
1453 SET_WORD(do_gadget_flags, 4 + 2);
1454 }
1455 else
1456 {
1457 /* GFLG_GADGIMAGE */
1458 SET_WORD(do_gadget_flags, 4);
1459 }
1460
1461 SET_WORD(do_gadget_activation, 1);
1462 SET_WORD(do_gadget_gadgettype, 1);
1463 SET_LONG(do_gadget_gadgetrender, BOOL_YES);
1464
1465 if (image2option)
1466 {
1467 SET_LONG(do_gadget_selectrender, BOOL_YES);
1468 }
1469 else
1470 {
1471 SET_LONG(do_gadget_selectrender, BOOL_NO);
1472 }
1473
1474 SET_LONG(do_gadget_gadgettext, 0);
1475 SET_LONG(do_gadget_mutualexclude, (1 << 31) | (tpdX << 8) | (tpdY << 0));
1476 SET_LONG(do_gadget_specialinfo, 0);
1477 SET_WORD(do_gadget_gadgetid, 0);
1478 SET_LONG(do_gadget_userdata, 1); /* full drawer data */
1479
1480 SET_BYTE(do_type, typeoption);
1481 SET_BYTE(do_pad, 0);
1482
1483 if (defaulttooloption)
1484 {
1485 SET_LONG(do_defaulttool, BOOL_YES);
1486 }
1487 else
1488 {
1489 SET_LONG(do_defaulttool, BOOL_NO);
1490 }
1491
1492 if (tooltypesoption)
1493 {
1494 SET_LONG(do_tooltypes, BOOL_YES);
1495 }
1496 else
1497 {
1498 SET_LONG(do_tooltypes, BOOL_NO);
1499 }
1500
1501 SET_LONG(do_currentx, iconleftoption);
1502 SET_LONG(do_currenty, icontopoption);
1503
1504 if (drawerdataoption)
1505 {
1506 SET_LONG(do_drawerdata, BOOL_YES);
1507 }
1508 else
1509 {
1510 SET_LONG(do_drawerdata, BOOL_NO);
1511 }
1512
1513
1514 SET_LONG(do_toolwindow, 0);
1515 SET_LONG(do_stacksize, stackoption);
1516
1517 if (fwrite(&dobj, 1, sizeof(dobj), outfile) != sizeof(dobj))
1518 {
1519 cleanup("Error writing diskobject structure to outfile!", 1);
1520 }
1521 }
1522
1523 /****************************************************************************************/
1524
1525 static void writeolddrawerdata(void)
1526 {
1527 struct olddrawerdata dd;
1528
1529 if (!drawerdataoption) return;
1530
1531 #undef ACT_STRUCT
1532 #define ACT_STRUCT dd
1533
1534 SET_WORD(dd_newwindow_leftedge, drawerleftoption);
1535 SET_WORD(dd_newwindow_topedge, drawertopoption);
1536 SET_WORD(dd_newwindow_width, drawerwidthoption);
1537 SET_WORD(dd_newwindow_height, drawerheightoption);
1538 SET_BYTE(dd_newwindow_detailpen, 255);
1539 SET_BYTE(dd_newwindow_blockpen, 255);
1540 SET_LONG(dd_newwindow_idcmpflags, 0);
1541 SET_LONG(dd_newwindow_flags, 0x240027f);
1542 SET_LONG(dd_newwindow_firstgadget, 0);
1543 SET_LONG(dd_newwindow_checkmark, 0);
1544 SET_LONG(dd_newwindow_title, 0);
1545 SET_LONG(dd_newwindow_screen, 0);
1546 SET_LONG(dd_newwindow_bitmap, 0);
1547 SET_WORD(dd_newwindow_minwidth, 90);
1548 SET_WORD(dd_newwindow_minheight, 40);
1549 SET_WORD(dd_newwindow_maxwidth, 65535);
1550 SET_WORD(dd_newwindow_maxheight, 65535);
1551 SET_WORD(dd_newwindow_type, 1);
1552 SET_LONG(dd_currentx, drawervleftoption);
1553 SET_LONG(dd_currenty, drawervtopoption);
1554
1555 if (fwrite(&dd, 1, sizeof(dd), outfile) != sizeof(dd))
1556 {
1557 cleanup("Error writing olddrawerdata structure to outfile!", 1);
1558 }
1559
1560 }
1561
1562
1563 /****************************************************************************************/
1564
1565 static void writenewdrawerdata(void)
1566 {
1567 struct newdrawerdata dd;
1568
1569 if (!drawerdataoption) return;
1570
1571 #undef ACT_STRUCT
1572 #define ACT_STRUCT dd
1573
1574 SET_LONG(dd_flags, drawershowoption);
1575 SET_WORD(dd_viewmodes, drawershowasoption);
1576
1577 if (fwrite(&dd, 1, sizeof(dd), outfile) != sizeof(dd))
1578 {
1579 cleanup("Error writing newdrawerdata structure to outfile!", 1);
1580 }
1581
1582 }
1583
1584 /****************************************************************************************/
1585
1586 static void writeword(WORD l)
1587 {
1588 UBYTE f[2];
1589
1590 f[0] = (l >> 8) & 0xFF;
1591 f[1] = l & 0xFF;
1592
1593 if (fwrite(f, 1, 2, outfile) != 2)
1594 {
1595 cleanup("Error writing word value!", 1);
1596 }
1597
1598 }
1599
1600 /****************************************************************************************/
1601
1602 static void writelong(LONG l)
1603 {
1604 UBYTE f[4];
1605
1606 f[0] = (l >> 24) & 0xFF;
1607 f[1] = (l >> 16) & 0xFF;
1608 f[2] = (l >> 8) & 0xFF;
1609 f[3] = l & 0xFF;
1610
1611 if (fwrite(f, 1, 4, outfile) != 4)
1612 {
1613 cleanup("Error writing long value!", 1);
1614 }
1615
1616 }
1617
1618 /****************************************************************************************/
1619
1620 static void writenormalstring(char *s)
1621 {
1622 int len = strlen(s) + 1;
1623
1624 if (fwrite(s, 1, len, outfile) != len)
1625 {
1626 cleanup("Error writing string!", 1);
1627 }
1628
1629 }
1630
1631 /****************************************************************************************/
1632
1633 static void writestring(char *s)
1634 {
1635 int len = strlen(s) + 1;
1636
1637 D(printf("String: \"%s\", length %d\n", s, len));
1638
1639 writelong(len);
1640
1641 if (fwrite(s, 1, len, outfile) != len)
1642 {
1643 cleanup("Error writing string!", 1);
1644 }
1645
1646 }
1647
1648 /****************************************************************************************/
1649
1650 static void writeimage(struct ILBMImage *img)
1651 {
1652 struct image i;
1653 LONG d, y;
1654
1655 #undef ACT_STRUCT
1656 #define ACT_STRUCT i
1657
1658 SET_WORD(leftedge, 0);
1659 SET_WORD(topedge, 0);
1660 SET_WORD(width, img->planarbmh.bmh_Width);
1661 SET_WORD(height, img->planarbmh.bmh_Height);
1662 SET_WORD(depth, img->planarbmh.bmh_Depth);
1663 SET_LONG(imagedata, BOOL_YES);
1664 SET_BYTE(planepick, (1 << img->planarbmh.bmh_Depth) - 1);
1665 SET_BYTE(planeonoff, 0);
1666 SET_LONG(nextimage, 0);
1667
1668 if (fwrite(&i, 1, sizeof(i), outfile) != sizeof(i))
1669 {
1670 cleanup("Error writing image structure to outfile!", 1);
1671 }
1672
1673 for(d = 0; d < img->planarbmh.bmh_Depth; d++)
1674 {
1675 UBYTE *dat = img->planarbuffer + img->bpr * d;
1676
1677 for(y = 0; y < img->planarbmh.bmh_Height; y++)
1678 {
1679 if(fwrite(dat, 1, img->bpr, outfile) != img->bpr)
1680 {
1681 cleanup("Error writing image data to outfile!", 1);
1682 }
1683 dat += (img->planarbmh.bmh_Depth * img->bpr);
1684 }
1685 }
1686
1687 }
1688
1689 /****************************************************************************************/
1690
1691 struct facechunk
1692 {
1693 UBYTE fc_width;
1694 UBYTE fc_height;
1695 UBYTE fc_flags;
1696 UBYTE fc_aspect;
1697 UBYTE fc_maxpalettebytes[2];
1698 };
1699
1700 /****************************************************************************************/
1701
1702 struct imagchunk
1703 {
1704 UBYTE ic_transparentcolour;
1705 UBYTE ic_numcolours;
1706 UBYTE ic_flags;
1707 UBYTE ic_imageformat;
1708 UBYTE ic_paletteformat;
1709 UBYTE ic_depth;
1710 UBYTE ic_numimagebytes[2];
1711 UBYTE ic_numpalettebytes[2];
1712 };
1713
1714 /****************************************************************************************/
1715
1716 static LONG writefacechunk(void)
1717 {
1718 struct facechunk fc;
1719 LONG palbytes;
1720
1721 #undef ACT_STRUCT
1722 #define ACT_STRUCT fc
1723
1724 writelong(ID_FACE);
1725 writelong(sizeof(struct facechunk));
1726
1727 SET_BYTE(fc_width, img1.bmh.bmh_Width - 1);
1728 SET_BYTE(fc_height, img1.bmh.bmh_Height - 1);
1729 SET_BYTE(fc_flags, 0);
1730 SET_BYTE(fc_aspect, 0); // 0x11);
1731
1732 palbytes = (img1.cmapentries > img2.cmapentries) ? img1.cmapentries : img2.cmapentries;
1733 palbytes = palbytes * 3;
1734
1735 SET_WORD(fc_maxpalettebytes, palbytes - 1);
1736
1737 if (fwrite(&fc, 1, sizeof(fc), outfile) != sizeof(fc))
1738 {
1739 cleanup("Error writing face chunk!", 1);
1740 }
1741
1742 return sizeof(struct facechunk) + 8;
1743 }
1744
1745 /****************************************************************************************/
1746
1747 /* createrle() based on ModifyIcon source by Dirk Stöcker */
1748
1749 /****************************************************************************************/
1750
1751 static char * createrle(unsigned long depth, unsigned char *dtype, LONG *dsize, unsigned long size,
1752 unsigned char *src)
1753 {
1754 int i, j, k;
1755 unsigned long bitbuf, numbits;
1756 unsigned char *buf;
1757 long ressize, numcopy, numequal;
1758
1759 buf = malloc(size * 2);
1760 if (!buf) return NULL;
1761
1762 numcopy = 0;
1763 numequal = 1;
1764 bitbuf = 0;
1765 numbits = 0;
1766 ressize = 0;
1767 k = 0; /* the really output pointer */
1768 for(i = 1; numequal || numcopy;)
1769 {
1770 if(i < size && numequal && (src[i-1] == src[i]))
1771 {
1772 ++numequal; ++i;
1773 }
1774 else if(i < size && numequal*depth <= 16)
1775 {
1776 numcopy += numequal; numequal = 1; ++i;
1777 }
1778 else
1779 {
1780 /* care for end case, where it maybe better to join the two */
1781 if(i == size && numcopy + numequal <= 128 && (numequal-1)*depth <= 8)
1782 {
1783 numcopy += numequal; numequal = 0;
1784 }
1785 if(numcopy)
1786 {
1787 if((j = numcopy) > 128) j = 128;
1788 bitbuf = (bitbuf<<8) | (j-1);
1789 numcopy -= j;
1790 }
1791 else
1792 {
1793 if((j = numequal) > 128) j = 128;
1794 bitbuf = (bitbuf<<8) | (256-(j-1));
1795 numequal -= j;
1796 k += j-1;
1797 j = 1;
1798 }
1799 buf[ressize++] = (bitbuf >> numbits);
1800 while(j--)
1801 {
1802 numbits += depth;
1803 bitbuf = (bitbuf<<depth) | src[k++];
1804 if(numbits >= 8)
1805 {
1806 numbits -= 8;
1807 buf[ressize++] = (bitbuf >> numbits);
1808 }
1809 }
1810 if(i < size && !numcopy && !numequal)
1811 {
1812 numequal = 1; ++i;
1813 }
1814 }
1815 }
1816 if(numbits)
1817 buf[ressize++] = bitbuf << (8-numbits);
1818
1819 if(ressize > size) /* no RLE */
1820 {
1821 ressize = size;
1822 *dtype = 0;
1823 for(i = 0; i < size; ++i)
1824 buf[i]= src[i];
1825 }
1826 else
1827 *dtype = 1;
1828
1829 *dsize = ressize;
1830
1831 return buf;
1832 }
1833
1834 /****************************************************************************************/
1835
1836 static LONG writeimagchunk(struct ILBMImage *img)
1837 {
1838 struct imagchunk ic;
1839 LONG imagsize;
1840 UBYTE skippalette = 0;
1841 UBYTE *pal, *gfx;
1842 LONG palsize, gfxsize;
1843 UBYTE palpacked, gfxpacked;
1844
1845 imagsize = sizeof(struct imagchunk);
1846
1847 /* if this is second image check whether palette is identical to
1848 the one of first image */
1849
1850 if (img == &img2)
1851 {
1852 if (img1.cmapentries == img2.cmapentries)
1853 {
1854 WORD i;
1855
1856 for (i = 0; i < img1.cmapentries; i++)
1857 {
1858 if (img1.rgb[i][0] != img2.rgb[i][0]) break;
1859 if (img1.rgb[i][1] != img2.rgb[i][1]) break;
1860 if (img1.rgb[i][2] != img2.rgb[i][2]) break;
1861 }
1862
1863 if (i == img1.cmapentries) skippalette = 1;
1864 }
1865 }
1866
1867 if (!skippalette)
1868 {
1869 pal = createrle(8,
1870 &palpacked,
1871 &palsize,
1872 img->cmapentries * 3,
1873 (unsigned char *)img->rgb);
1874
1875 imagsize += palsize;
1876 }
1877
1878 gfx = createrle(img->bmh.bmh_Depth,
1879 &gfxpacked,
1880 &gfxsize,
1881 img->bmh.bmh_Width * img->bmh.bmh_Height,
1882 img->chunkybuffer);
1883
1884 imagsize += gfxsize;
1885
1886 #undef ACT_STRUCT
1887 #define ACT_STRUCT ic
1888
1889 SET_BYTE(ic_transparentcolour, transparentoption);
1890 if (skippalette)
1891 {
1892 SET_BYTE(ic_numcolours, 0);
1893 SET_BYTE(ic_flags, (transparentoption != -1) ? 1 : 0); /* 1 = HasTransparentColour */
1894 SET_BYTE(ic_paletteformat, 0);
1895 SET_WORD(ic_numpalettebytes, 0);
1896 }
1897 else
1898 {
1899 SET_BYTE(ic_numcolours, img->cmapentries - 1);
1900 SET_BYTE(ic_flags, (transparentoption != -1) ? 3 : 2); /* 2 = HasPalette */
1901 SET_BYTE(ic_paletteformat, palpacked);
1902 SET_WORD(ic_numpalettebytes, palsize - 1);
1903 }
1904
1905 SET_BYTE(ic_imageformat, gfxpacked);
1906 SET_BYTE(ic_depth, img->bmh.bmh_Depth);
1907 SET_WORD(ic_numimagebytes, gfxsize - 1);
1908
1909 writelong(ID_IMAG);
1910 writelong(imagsize);
1911
1912 if (fwrite(&ic, 1, sizeof(ic), outfile) != sizeof(ic))
1913 {
1914 cleanup("Error writing imag chunk!", 1);
1915 }
1916
1917 if (fwrite(gfx, 1, gfxsize, outfile) != gfxsize)
1918 {
1919 cleanup("Error write gfx data in imag chunk!", 1);
1920 }
1921
1922 if (!skippalette)
1923 {
1924 if (fwrite(pal, 1, palsize, outfile) != palsize)
1925 {
1926 cleanup("Error write palette data in imag chunk!", 1);
1927 }
1928 }
1929
1930 if (imagsize & 1)
1931 {
1932 UBYTE dummy = 0;
1933
1934 if (fwrite(&dummy, 1, 1, outfile) != 1)
1935 {
1936 cleanup("Error writing imag chunk!", 1);
1937 }
1938
1939 imagsize++;
1940 }
1941
1942 return imagsize + 8;
1943 }
1944
1945 /****************************************************************************************/
1946 static LONG writeargb(APTR argb, ULONG argb_size)
1947 {
1948 LONG formsize = 10;
1949 struct ARGB35_Header {
1950 ULONG ztype; /* Always 1 */
1951 ULONG zsize; /* Compressed size, or -1 */
1952 UWORD resv; /* Always 0 */
1953 } ahdr;
1954 Bytef *zdest;
1955 uLongf zsize, size;
1956 int err;
1957
1958 zsize = size = argb_size;
1959
1960 zdest = malloc(zsize);
1961 if (!zdest)
1962 return 0;
1963
1964 err = compress(zdest, &zsize, argb, size);
1965 if (err != Z_OK) {
1966 free(zdest);
1967 return 0;
1968 }
1969
1970 D(printf("ARGB: Compressed %d => %d\n", size, zsize));
1971
1972 writelong(ID_ARGB);
1973 formsize = 10 + zsize;
1974 writelong(formsize);
1975 writelong(1);
1976 writelong(zsize);
1977 writeword(0);
1978 fwrite(zdest, 1, zsize, outfile);
1979 if (zsize & 1) {
1980 char c = 0;
1981 fwrite(&c, 1, 1, outfile);
1982 }
1983
1984 free(zdest);
1985
1986 if (formsize & 1)
1987 formsize++;
1988 return 8 + formsize;
1989 }
1990
1991 /****************************************************************************************/
1992
1993 static void write35data(void)
1994 {
1995 LONG formsize = 4;
1996 LONG formsizeseek;
1997
1998 if (nosaveIFF)
1999 return;
2000
2001 writelong(ID_FORM);
2002 formsizeseek = ftell(outfile);
2003 writelong(0x12345678);
2004 writelong(ID_ICON);
2005
2006 formsize += writefacechunk();
2007 formsize += writeimagchunk(&img1);
2008 if (image2option) formsize += writeimagchunk(&img2);
2009
2010 if (!nosaveARGB && img1.argb) {
2011 formsize += writeargb(img1.argb, img1.argb_size);
2012 }
2013
2014 if (!nosaveARGB && img2.argb) {
2015 formsize += writeargb(img2.argb, img2.argb_size);
2016 }
2017
2018 if (!nosavePNG && img1.png) {
2019 writelong(ID_PNG);
2020 writelong(img1.png_size);
2021 fwrite(img1.png, 1, img1.png_size, outfile);
2022 if (img1.png_size & 1) {
2023 char c = 0;
2024 fwrite(&c, 1, 1, outfile);
2025 img1.png_size++;
2026 }
2027 formsize += 8 + img1.png_size;
2028 }
2029
2030 if (!nosavePNG && img2.png) {
2031 writelong(ID_PNG);
2032 writelong(img2.png_size);
2033 fwrite(img2.png, 1, img2.png_size, outfile);
2034 if (img2.png_size & 1) {
2035 char c = 0;
2036 fwrite(&c, 1, 1, outfile);
2037 img2.png_size++;
2038 }
2039 formsize += 8 + img2.png_size;
2040 }
2041
2042 fseek(outfile, formsizeseek, SEEK_SET);
2043 writelong(formsize);
2044 }
2045
2046 /****************************************************************************************/
2047
2048 static void writeicon(void)
2049 {
2050 struct diskobject dobj;
2051
2052 D(printf("Writing %s\n", outfilename));
2053 outfile = fopen(outfilename, "wb");
2054 if (!outfile) cleanup("Can't open output file for writing!", 1);
2055
2056 writediskobject();
2057 writeolddrawerdata();
2058 writeimage(&img1);
2059
2060 if (image2option) writeimage(&img2);
2061
2062 if (defaulttooloption) writestring(defaulttooloption);
2063
2064 if (tooltypesoption)
2065 {
2066 char **strarray;
2067 LONG numtooltypes = 0;
2068
2069 for(strarray = tooltypesoption; *strarray; strarray++, numtooltypes++);
2070
2071 writelong((numtooltypes + 1) * 4);
2072
2073 for(strarray = tooltypesoption; *strarray; strarray++)
2074 {
2075 writestring(*strarray);
2076 }
2077
2078 }
2079
2080 /* toolwindow would have to be saved in between here if there is any */
2081
2082 writenewdrawerdata();
2083
2084 write35data();
2085
2086 }
2087
2088 /****************************************************************************************/
2089
2090 static void remapicon(void)
2091 {
2092 remapplanar(&img1, &std4colpal);
2093 if (image2option) remapplanar(&img2, &std4colpal);
2094 }
2095
2096 /****************************************************************************************/
2097
2098 int main(int argc, char **argv)
2099 {
2100 getarguments(argc, argv);
2101 parseiconsource();
2102 loadimage(image1option, &img1);
2103 if (image2option) {
2104 loadimage(image2option, &img2);
2105 if ((img2.bmh.bmh_Width && img2.bmh.bmh_Width != img1.bmh.bmh_Width) ||
2106 (img2.bmh.bmh_Height && img2.bmh.bmh_Height != img1.bmh.bmh_Height)) {
2107 fprintf(stderr, "%s: Image %s (%dx%d) is not the same size as Image %s (%dx%d)\n", argv[0], image1option, img1.bmh.bmh_Width, img1.bmh.bmh_Height, image2option, img2.bmh.bmh_Width, img2.bmh.bmh_Height);
2108 }
2109 }
2110
2111 remapicon();
2112 writeicon();
2113
2114 cleanup(0, 0);
2115 }
2116
2117 /****************************************************************************************/
Mirror of AROS' svn.