tools/ilbmtoicon/ilbmtoicon.c

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