iff/iff.c

   1 /*
   2 THE COMPUTER CODE CONTAINED HEREIN IS THE SOLE PROPERTY OF PARALLAX
   3 SOFTWARE CORPORATION ("PARALLAX").  PARALLAX, IN DISTRIBUTING THE CODE TO
   4 END-USERS, AND SUBJECT TO ALL OF THE TERMS AND CONDITIONS HEREIN, GRANTS A
   5 ROYALTY-FREE, PERPETUAL LICENSE TO SUCH END-USERS FOR USE BY SUCH END-USERS
   6 IN USING, DISPLAYING,  AND CREATING DERIVATIVE WORKS THEREOF, SO LONG AS
   7 SUCH USE, DISPLAY OR CREATION IS FOR NON-COMMERCIAL, ROYALTY OR REVENUE
   8 FREE PURPOSES.  IN NO EVENT SHALL THE END-USER USE THE COMPUTER CODE
   9 CONTAINED HEREIN FOR REVENUE-BEARING PURPOSES.  THE END-USER UNDERSTANDS
  10 AND AGREES TO THE TERMS HEREIN AND ACCEPTS THE SAME BY USE OF THIS FILE.
  11 COPYRIGHT 1993-1999 PARALLAX SOFTWARE CORPORATION.  ALL RIGHTS RESERVED.
  12 */
  13
  14 #ifdef HAVE_CONFIG_H
  15 #include <conf.h>
  16 #endif
  17
  18 #ifdef RCS
  19 static char rcsid[] = "$Id: iff.c,v 1.4 2001-01-31 15:17:48 bradleyb Exp $";
  20 #endif
  21
  22 #define COMPRESS                1       //do the RLE or not? (for debugging mostly)
  23 #define WRITE_TINY      0       //should we write a TINY chunk?
  24
  25 #define MIN_COMPRESS_WIDTH      65      //don't compress if less than this wide
  26
  27 #include <stdio.h>
  28 #include <stdlib.h>
  29 #include <string.h>
  30
  31 #include "u_mem.h"
  32 #include "iff.h"
  33
  34 //#include "nocfile.h"
  35 #include "cfile.h"
  36 #include "error.h"
  37
  38 //Internal constants and structures for this library
  39
  40 //Type values for bitmaps
  41 #define TYPE_PBM                0
  42 #define TYPE_ILBM               1
  43
  44 //Compression types
  45 #define cmpNone 0
  46 #define cmpByteRun1     1
  47
  48 //Masking types
  49 #define mskNone 0
  50 #define mskHasMask      1
  51 #define mskHasTransparentColor 2
  52
  53 //Palette entry structure
  54 typedef struct pal_entry {byte r,g,b;} pal_entry;
  55
  56 //structure of the header in the file
  57 typedef struct iff_bitmap_header {
  58         short w,h;                                              //width and height of this bitmap
  59         short x,y;                                              //generally unused
  60         short type;                                             //see types above
  61         short transparentcolor;         //which color is transparent (if any)
  62         short pagewidth,pageheight; //width & height of source screen
  63         byte nplanes;                                   //number of planes (8 for 256 color image)
  64         byte masking,compression;       //see constants above
  65         byte xaspect,yaspect;           //aspect ratio (usually 5/6)
  66         pal_entry palette[256];         //the palette for this bitmap
  67         ubyte *raw_data;                                //ptr to array of data
  68         short row_size;                         //offset to next row
  69 } iff_bitmap_header;
  70
  71 ubyte iff_transparent_color;
  72 ubyte iff_has_transparency;     // 0=no transparency, 1=iff_transparent_color is valid
  73
  74 typedef struct fake_file {
  75         ubyte *data;
  76         int position;
  77         int length;
  78 } FFILE;
  79
  80 #define MIN(a,b) ((a<b)?a:b)
  81
  82 #define MAKE_SIG(a,b,c,d) (((long)(a)<<24)+((long)(b)<<16)+((c)<<8)+(d))
  83
  84 #define form_sig MAKE_SIG('F','O','R','M')
  85 #define ilbm_sig MAKE_SIG('I','L','B','M')
  86 #define body_sig MAKE_SIG('B','O','D','Y')
  87 #define pbm_sig  MAKE_SIG('P','B','M',' ')
  88 #define bmhd_sig MAKE_SIG('B','M','H','D')
  89 #define anhd_sig MAKE_SIG('A','N','H','D')
  90 #define cmap_sig MAKE_SIG('C','M','A','P')
  91 #define tiny_sig MAKE_SIG('T','I','N','Y')
  92 #define anim_sig MAKE_SIG('A','N','I','M')
  93 #define dlta_sig MAKE_SIG('D','L','T','A')
  94
  95 #ifndef NDEBUG
  96 //void printsig(long s)
  97 //{
  98 //      char *t=(char *) &s;
  99 //
 100 ///*  printf("%c%c%c%c",*(&s+3),*(&s+2),*(&s+1),s);*/
 101 //      printf("%c%c%c%c",t[3],t[2],t[1],t[0]);
 102 //}
 103 #endif
 104
 105 long get_sig(FFILE *f)
 106 {
 107         char s[4];
 108
 109 //      if ((s[3]=cfgetc(f))==EOF) return(EOF);
 110 //      if ((s[2]=cfgetc(f))==EOF) return(EOF);
 111 //      if ((s[1]=cfgetc(f))==EOF) return(EOF);
 112 //      if ((s[0]=cfgetc(f))==EOF) return(EOF);
 113
 114 #ifndef MACINTOSH
 115         if (f->position>=f->length) return EOF;
 116         s[3] = f->data[f->position++];
 117         if (f->position>=f->length) return EOF;
 118         s[2] = f->data[f->position++];
 119         if (f->position>=f->length) return EOF;
 120         s[1] = f->data[f->position++];
 121         if (f->position>=f->length) return EOF;
 122         s[0] = f->data[f->position++];
 123 #else
 124         if (f->position>=f->length) return EOF;
 125         s[0] = f->data[f->position++];
 126         if (f->position>=f->length) return EOF;
 127         s[1] = f->data[f->position++];
 128         if (f->position>=f->length) return EOF;
 129         s[2] = f->data[f->position++];
 130         if (f->position>=f->length) return EOF;
 131         s[3] = f->data[f->position++];
 132 #endif
 133
 134         return(*((long *) s));
 135 }
 136
 137 int put_sig(long sig,FILE *f)
 138 {
 139         char *s = (char *) &sig;
 140
 141         fputc(s[3],f);
 142         fputc(s[2],f);
 143         fputc(s[1],f);
 144         return fputc(s[0],f);
 145
 146 }
 147
 148 char get_byte(FFILE *f)
 149 {
 150         //return cfgetc(f);
 151         return f->data[f->position++];
 152 }
 153
 154 int put_byte(unsigned char c,FILE *f)
 155 {
 156         return fputc(c,f);
 157 }
 158
 159
 160
 161 int get_word(FFILE *f)
 162 {
 163         unsigned char c0,c1;
 164
 165 //      c1=cfgetc(f);
 166 //      c0=cfgetc(f);
 167
 168         if (f->position>=f->length) return EOF;
 169         c1 = f->data[f->position++];
 170         if (f->position>=f->length) return EOF;
 171         c0 = f->data[f->position++];
 172
 173         if (c0==0xff) return(EOF);
 174
 175         return(((int)c1<<8) + c0);
 176
 177 }
 178
 179 int put_word(int n,FILE *f)
 180 {
 181         unsigned char c0,c1;
 182
 183         c0 = (n & 0xff00) >> 8;
 184         c1 = n & 0xff;
 185
 186         put_byte(c0,f);
 187         return put_byte(c1,f);
 188 }
 189
 190 int put_long(long n,FILE *f)
 191 {
 192         int n0,n1;
 193
 194         n0 = (int) ((n & 0xffff0000l) >> 16);
 195         n1 = (int) (n & 0xffff);
 196
 197         put_word(n0,f);
 198         return put_word(n1,f);
 199
 200 }
 201
 202 long get_long(FFILE *f)
 203 {
 204         unsigned char c0,c1,c2,c3;
 205
 206         //c3=cfgetc(f);
 207         //c2=cfgetc(f);
 208         //c1=cfgetc(f);
 209         //c0=cfgetc(f);
 210
 211         if (f->position>=f->length) return EOF;
 212         c3 = f->data[f->position++];
 213         if (f->position>=f->length) return EOF;
 214         c2 = f->data[f->position++];
 215         if (f->position>=f->length) return EOF;
 216         c1 = f->data[f->position++];
 217         if (f->position>=f->length) return EOF;
 218         c0 = f->data[f->position++];
 219
 220 //printf("get_long %x %x %x %x\n",c3,c2,c1,c0);
 221
 222 //  if (c0==0xff) return(EOF);
 223
 224         return(((long)c3<<24) + ((long)c2<<16) + ((long)c1<<8) + c0);
 225
 226 }
 227
 228 int parse_bmhd(FFILE *ifile,long len,iff_bitmap_header *bmheader)
 229 {
 230         len++;  /* so no "parm not used" warning */
 231
 232 //  debug("parsing bmhd len=%ld\n",len);
 233
 234         bmheader->w = get_word(ifile);
 235         bmheader->h = get_word(ifile);
 236         bmheader->x = get_word(ifile);
 237         bmheader->y = get_word(ifile);
 238
 239         bmheader->nplanes = get_byte(ifile);
 240         bmheader->masking = get_byte(ifile);
 241         bmheader->compression = get_byte(ifile);
 242         get_byte(ifile);        /* skip pad */
 243
 244         bmheader->transparentcolor = get_word(ifile);
 245         bmheader->xaspect = get_byte(ifile);
 246         bmheader->yaspect = get_byte(ifile);
 247
 248         bmheader->pagewidth = get_word(ifile);
 249         bmheader->pageheight = get_word(ifile);
 250
 251         iff_transparent_color = bmheader->transparentcolor;
 252
 253         iff_has_transparency = 0;
 254
 255         if (bmheader->masking == mskHasTransparentColor)
 256                 iff_has_transparency = 1;
 257
 258         else if (bmheader->masking != mskNone && bmheader->masking != mskHasMask)
 259                 return IFF_UNKNOWN_MASK;
 260
 261 //  debug("w,h=%d,%d x,y=%d,%d\n",w,h,x,y);
 262 //  debug("nplanes=%d, masking=%d ,compression=%d, transcolor=%d\n",nplanes,masking,compression,transparentcolor);
 263
 264         return IFF_NO_ERROR;
 265 }
 266
 267
 268 //  the buffer pointed to by raw_data is stuffed with a pointer to decompressed pixel data
 269 int parse_body(FFILE *ifile,long len,iff_bitmap_header *bmheader)
 270 {
 271         unsigned char  *p=bmheader->raw_data;
 272         int width,depth;
 273         signed char n;
 274         int nn,wid_cnt,end_cnt,plane;
 275         char ignore=0;
 276         unsigned char *data_end;
 277         int end_pos;
 278         #ifndef NDEBUG
 279         int row_count=0;
 280         #endif
 281
 282         width=0;
 283         depth=0;
 284
 285         end_pos = ifile->position + len;
 286         if (len&1)
 287                 end_pos++;
 288
 289         if (bmheader->type == TYPE_PBM) {
 290                 width=bmheader->w;
 291                 depth=1;
 292         } else if (bmheader->type == TYPE_ILBM) {
 293                 width = (bmheader->w+7)/8;
 294                 depth=bmheader->nplanes;
 295         }
 296
 297         end_cnt = (width&1)?-1:0;
 298
 299         data_end = p + width*bmheader->h*depth;
 300
 301         if (bmheader->compression == cmpNone) {        /* no compression */
 302                 int y;
 303
 304                 for (y=bmheader->h;y;y--) {
 305                         int x;
 306 //                      for (x=bmheader->w;x;x--) *p++=cfgetc(ifile);
 307 //                      cfread(p, bmheader->w, 1, ifile);
 308 //                      p += bmheader->w;
 309
 310                         for (x=0;x<width*depth;x++)
 311                                 *p++=ifile->data[ifile->position++];
 312
 313                         if (bmheader->masking == mskHasMask)
 314                                 ifile->position += width;                               //skip mask!
 315
 316 //                      if (bmheader->w & 1) ignore = cfgetc(ifile);
 317                         if (bmheader->w & 1) ifile->position++;
 318                 }
 319
 320                 //cnt = len - bmheader->h * ((bmheader->w+1)&~1);
 321
 322         }
 323         else if (bmheader->compression == cmpByteRun1)
 324                 for (wid_cnt=width,plane=0;ifile->position<end_pos && p<data_end;) {
 325                         unsigned char c;
 326
 327 //                      if (old_cnt-cnt > 2048) {
 328 //              printf(".");
 329 //                              old_cnt=cnt;
 330 //                      }
 331
 332                         if (wid_cnt == end_cnt) {
 333                                 wid_cnt = width;
 334                                 plane++;
 335                                 if ((bmheader->masking == mskHasMask && plane==depth+1) ||
 336                                     (bmheader->masking != mskHasMask && plane==depth))
 337                                         plane=0;
 338                         }
 339
 340                         Assert(wid_cnt > end_cnt);
 341
 342                         //n=cfgetc(ifile);
 343                         n=ifile->data[ifile->position++];
 344
 345                         if (n >= 0) {                       // copy next n+1 bytes from source, they are not compressed
 346                                 nn = (int) n+1;
 347                                 wid_cnt -= nn;
 348                                 if (wid_cnt==-1) {--nn; Assert(width&1);}
 349                                 if (plane==depth)       //masking row
 350                                         ifile->position += nn;
 351                                 else
 352                                         while (nn--) *p++=ifile->data[ifile->position++];
 353                                 if (wid_cnt==-1) ifile->position++;
 354                         }
 355                         else if (n>=-127) {             // next -n + 1 bytes are following byte
 356                                 c=ifile->data[ifile->position++];
 357                                 nn = (int) -n+1;
 358                                 wid_cnt -= nn;
 359                                 if (wid_cnt==-1) {--nn; Assert(width&1);}
 360                                 if (plane!=depth)       //not masking row
 361                                         {memset(p,c,nn); p+=nn;}
 362                         }
 363
 364                         #ifndef NDEBUG
 365                         if ((p-bmheader->raw_data) % width == 0)
 366                                         row_count++;
 367
 368                         Assert((p-bmheader->raw_data) - (width*row_count) < width);
 369                         #endif
 370
 371                 }
 372
 373         if (p!=data_end)                                //if we don't have the whole bitmap...
 374                 return IFF_CORRUPT;             //...the give an error
 375
 376         //Pretend we read the whole chuck, because if we didn't, it's because
 377         //we didn't read the last mask like or the last rle record for padding
 378         //or whatever and it's not important, because we check to make sure
 379         //we got the while bitmap, and that's what really counts.
 380
 381         ifile->position = end_pos;
 382
 383         if (ignore) ignore++;   // haha, suppress the evil warning message
 384
 385         return IFF_NO_ERROR;
 386 }
 387
 388 //modify passed bitmap
 389 int parse_delta(FFILE *ifile,long len,iff_bitmap_header *bmheader)
 390 {
 391         unsigned char  *p=bmheader->raw_data;
 392         int y;
 393         long chunk_end = ifile->position + len;
 394
 395         get_long(ifile);                //longword, seems to be equal to 4.  Don't know what it is
 396
 397         for (y=0;y<bmheader->h;y++) {
 398                 ubyte n_items;
 399                 int cnt = bmheader->w;
 400                 ubyte code;
 401
 402                 n_items = get_byte(ifile);
 403
 404                 while (n_items--) {
 405
 406                         code = get_byte(ifile);
 407
 408                         if (code==0) {                          //repeat
 409                                 ubyte rep,val;
 410
 411                                 rep = get_byte(ifile);
 412                                 val = get_byte(ifile);
 413
 414                                 cnt -= rep;
 415                                 if (cnt==-1)
 416                                         rep--;
 417                                 while (rep--)
 418                                         *p++ = val;
 419                         }
 420                         else if (code > 0x80) { //skip
 421                                 cnt -= (code-0x80);
 422                                 p += (code-0x80);
 423                                 if (cnt==-1)
 424                                         p--;
 425                         }
 426                         else {                                          //literal
 427                                 cnt -= code;
 428                                 if (cnt==-1)
 429                                         code--;
 430
 431                                 while (code--)
 432                                         *p++ = get_byte(ifile);
 433
 434                                 if (cnt==-1)
 435                                         get_byte(ifile);
 436                         }
 437
 438                 }
 439
 440                 if (cnt == -1) {
 441                         if (!bmheader->w&1)
 442                                 return IFF_CORRUPT;
 443                 }
 444                 else if (cnt)
 445                         return IFF_CORRUPT;
 446         }
 447
 448         if (ifile->position == chunk_end-1)             //pad
 449                 ifile->position++;
 450
 451         if (ifile->position != chunk_end)
 452                 return IFF_CORRUPT;
 453         else
 454                 return IFF_NO_ERROR;
 455 }
 456
 457 //  the buffer pointed to by raw_data is stuffed with a pointer to bitplane pixel data
 458 void skip_chunk(FFILE *ifile,long len)
 459 {
 460         //int c,i;
 461         int ilen;
 462         ilen = (len+1) & ~1;
 463
 464 //printf( "Skipping %d chunk\n", ilen );
 465
 466         ifile->position += ilen;
 467
 468         if (ifile->position >= ifile->length )  {
 469                 ifile->position = ifile->length;
 470         }
 471
 472
 473 //      for (i=0; i<ilen; i++ )
 474 //              c = cfgetc(ifile);
 475         //Assert(cfseek(ifile,ilen,SEEK_CUR)==0);
 476 }
 477
 478 //read an ILBM or PBM file
 479 // Pass pointer to opened file, and to empty bitmap_header structure, and form length
 480 int iff_parse_ilbm_pbm(FFILE *ifile,long form_type,iff_bitmap_header *bmheader,int form_len,grs_bitmap *prev_bm)
 481 {
 482         long sig,len;
 483         //char ignore=0;
 484         long start_pos,end_pos;
 485
 486         start_pos = ifile->position;
 487         end_pos = start_pos-4+form_len;
 488
 489 //      printf(" %ld ",form_len);
 490 //      printsig(form_type);
 491 //      printf("\n");
 492
 493                         if (form_type == pbm_sig)
 494                                 bmheader->type = TYPE_PBM;
 495                         else
 496                                 bmheader->type = TYPE_ILBM;
 497
 498                         while ((ifile->position < end_pos) && (sig=get_sig(ifile)) != EOF) {
 499
 500                                 len=get_long(ifile);
 501                                 if (len==EOF) break;
 502
 503 //              printf(" ");
 504 //              printsig(sig);
 505 //              printf(" %ld\n",len);
 506
 507                                 switch (sig) {
 508
 509                                         case bmhd_sig: {
 510                                                 int ret;
 511                                                 int save_w=bmheader->w,save_h=bmheader->h;
 512
 513                                                 //printf("Parsing header\n");
 514
 515                                                 ret = parse_bmhd(ifile,len,bmheader);
 516
 517                                                 if (ret != IFF_NO_ERROR)
 518                                                         return ret;
 519
 520                                                 if (bmheader->raw_data) {
 521
 522                                                         if (save_w != bmheader->w  ||  save_h != bmheader->h)
 523                                                                 return IFF_BM_MISMATCH;
 524
 525                                                 }
 526                                                 else {
 527
 528                                                         MALLOC( bmheader->raw_data, ubyte, bmheader->w * bmheader->h );
 529                                                         if (!bmheader->raw_data)
 530                                                                 return IFF_NO_MEM;
 531                                                 }
 532
 533                                                 break;
 534
 535                                         }
 536
 537                                         case anhd_sig:
 538
 539                                                 if (!prev_bm) return IFF_CORRUPT;
 540
 541                                                 bmheader->w = prev_bm->bm_w;
 542                                                 bmheader->h = prev_bm->bm_h;
 543                                                 bmheader->type = prev_bm->bm_type;
 544
 545                                                 MALLOC( bmheader->raw_data, ubyte, bmheader->w * bmheader->h );
 546
 547                                                 memcpy(bmheader->raw_data, prev_bm->bm_data, bmheader->w * bmheader->h );
 548                                                 skip_chunk(ifile,len);
 549
 550                                                 break;
 551
 552                                         case cmap_sig:
 553                                         {
 554                                                 int ncolors=(int) (len/3),cnum;
 555                                                 unsigned char r,g,b;
 556
 557                                                 //printf("Parsing RGB map\n");
 558                                                 for (cnum=0;cnum<ncolors;cnum++) {
 559 //                                                      r=cfgetc(ifile);
 560 //                                                      g=cfgetc(ifile);
 561 //                                                      b=cfgetc(ifile);
 562                                                         r = ifile->data[ifile->position++];
 563                                                         g = ifile->data[ifile->position++];
 564                                                         b = ifile->data[ifile->position++];
 565                                                         r >>= 2; bmheader->palette[cnum].r = r;
 566                                                         g >>= 2; bmheader->palette[cnum].g = g;
 567                                                         b >>= 2; bmheader->palette[cnum].b = b;
 568                                                 }
 569                                                 //if (len & 1) ignore = cfgetc(ifile);
 570                                                 if (len & 1 ) ifile->position++;
 571
 572                                                 break;
 573                                         }
 574
 575                                         case body_sig:
 576                                         {
 577                                                 int r;
 578                                                 //printf("Parsing body\n");
 579                                                 if ((r=parse_body(ifile,len,bmheader))!=IFF_NO_ERROR)
 580                                                         return r;
 581                                                 break;
 582                                         }
 583                                         case dlta_sig:
 584                                         {
 585                                                 int r;
 586                                                 if ((r=parse_delta(ifile,len,bmheader))!=IFF_NO_ERROR)
 587                                                         return r;
 588                                                 break;
 589                                         }
 590                                         default:
 591                                                 skip_chunk(ifile,len);
 592                                                 break;
 593                                 }
 594                         }
 595
 596         //if (ignore) ignore++;
 597
 598         if (ifile->position != start_pos-4+form_len)
 599                 return IFF_CORRUPT;
 600
 601         return IFF_NO_ERROR;    /* ok! */
 602 }
 603
 604 //convert an ILBM file to a PBM file
 605 int convert_ilbm_to_pbm(iff_bitmap_header *bmheader)
 606 {
 607         int x,y,p;
 608         byte *new_data,*destptr,*rowptr;
 609         int bytes_per_row,byteofs;
 610         ubyte checkmask,newbyte,setbit;
 611
 612         MALLOC( new_data, byte, bmheader->w * bmheader->h );
 613         if (new_data == NULL) return IFF_NO_MEM;
 614
 615         destptr = new_data;
 616
 617         bytes_per_row = 2*((bmheader->w+15)/16);
 618
 619         for (y=0;y<bmheader->h;y++) {
 620
 621                 rowptr = &bmheader->raw_data[y * bytes_per_row * bmheader->nplanes];
 622
 623                 for (x=0,checkmask=0x80;x<bmheader->w;x++) {
 624
 625                         byteofs = x >> 3;
 626
 627                         for (p=newbyte=0,setbit=1;p<bmheader->nplanes;p++) {
 628
 629                                 if (rowptr[bytes_per_row * p + byteofs] & checkmask)
 630                                         newbyte |= setbit;
 631
 632                                 setbit <<= 1;
 633                         }
 634
 635                         *destptr++ = newbyte;
 636
 637                         if ((checkmask >>= 1) == 0) checkmask=0x80;
 638                 }
 639
 640         }
 641
 642         d_free(bmheader->raw_data);
 643         bmheader->raw_data = new_data;
 644
 645         bmheader->type = TYPE_PBM;
 646
 647         return IFF_NO_ERROR;
 648 }
 649
 650 #define INDEX_TO_15BPP(i) ((short)((((palptr[(i)].r/2)&31)<<10)+(((palptr[(i)].g/2)&31)<<5)+((palptr[(i)].b/2 )&31)))
 651
 652 int convert_rgb15(grs_bitmap *bm,iff_bitmap_header *bmheader)
 653 {
 654         ushort *new_data;
 655         int x,y;
 656         int newptr = 0;
 657         pal_entry *palptr;
 658
 659         palptr = bmheader->palette;
 660
 661 //        if ((new_data = d_malloc(bm->bm_w * bm->bm_h * 2)) == NULL)
 662 //            {ret=IFF_NO_MEM; goto done;}
 663        MALLOC(new_data, ushort, bm->bm_w * bm->bm_h * 2);
 664        if (new_data == NULL)
 665            return IFF_NO_MEM;
 666
 667         for (y=0; y<bm->bm_h; y++) {
 668
 669                 for (x=0; x<bmheader->w; x++)
 670                         new_data[newptr++] = INDEX_TO_15BPP(bmheader->raw_data[y*bmheader->w+x]);
 671
 672         }
 673
 674         d_free(bm->bm_data);                            //get rid of old-style data
 675         bm->bm_data = (ubyte *) new_data;                       //..and point to new data
 676
 677         bm->bm_rowsize *= 2;                            //two bytes per row
 678
 679         return IFF_NO_ERROR;
 680
 681 }
 682
 683 //read in a entire file into a fake file structure
 684 int open_fake_file(char *ifilename,FFILE *ffile)
 685 {
 686         CFILE *ifile;
 687         int ret;
 688
 689         //printf( "Reading %s\n", ifilename );
 690
 691         ffile->data=NULL;
 692
 693         if ((ifile = cfopen(ifilename,"rb")) == NULL) return IFF_NO_FILE;
 694
 695         ffile->length = cfilelength(ifile);
 696
 697         MALLOC(ffile->data,ubyte,ffile->length);
 698
 699         if (cfread(ffile->data, 1, ffile->length, ifile) < ffile->length)
 700                 ret = IFF_READ_ERROR;
 701         else
 702                 ret = IFF_NO_ERROR;
 703
 704         ffile->position = 0;
 705
 706         if (ifile) cfclose(ifile);
 707
 708         return ret;
 709 }
 710
 711 void close_fake_file(FFILE *f)
 712 {
 713         if (f->data)
 714                 d_free(f->data);
 715
 716         f->data = NULL;
 717 }
 718
 719 //copy an iff header structure to a grs_bitmap structure
 720 void copy_iff_to_grs(grs_bitmap *bm,iff_bitmap_header *bmheader)
 721 {
 722         bm->bm_x = bm->bm_y = 0;
 723         bm->bm_w = bmheader->w;
 724         bm->bm_h = bmheader->h;
 725         bm->bm_type = bmheader->type;
 726         bm->bm_rowsize = bmheader->w;
 727         bm->bm_data = bmheader->raw_data;
 728
 729         bm->bm_flags = bm->bm_handle = 0;
 730
 731 }
 732
 733 //if bm->bm_data is set, use it (making sure w & h are correct), else
 734 //allocate the memory
 735 int iff_parse_bitmap(FFILE *ifile,grs_bitmap *bm,int bitmap_type,byte *palette,grs_bitmap *prev_bm)
 736 {
 737         int ret;                        //return code
 738         iff_bitmap_header bmheader;
 739         long sig,form_len;
 740         long form_type;
 741
 742         bmheader.raw_data = bm->bm_data;
 743
 744         if (bmheader.raw_data) {
 745                 bmheader.w = bm->bm_w;
 746                 bmheader.h = bm->bm_h;
 747         }
 748
 749         sig=get_sig(ifile);
 750
 751         if (sig != form_sig) {
 752                 ret = IFF_NOT_IFF;
 753                 goto done;
 754         }
 755
 756         form_len = get_long(ifile);
 757
 758         form_type = get_sig(ifile);
 759
 760         if (form_type == anim_sig)
 761                 ret = IFF_FORM_ANIM;
 762         else if ((form_type == pbm_sig) || (form_type == ilbm_sig))
 763                 ret = iff_parse_ilbm_pbm(ifile,form_type,&bmheader,form_len,prev_bm);
 764         else
 765                 ret = IFF_UNKNOWN_FORM;
 766
 767         if (ret != IFF_NO_ERROR) {              //got an error parsing
 768                 if (bmheader.raw_data) d_free(bmheader.raw_data);
 769                 goto done;
 770         }
 771
 772         //If IFF file is ILBM, convert to PPB
 773         if (bmheader.type == TYPE_ILBM) {
 774
 775                 ret = convert_ilbm_to_pbm(&bmheader);
 776
 777                 if (ret != IFF_NO_ERROR) goto done;
 778         }
 779
 780         //Copy data from iff_bitmap_header structure into grs_bitmap structure
 781
 782         copy_iff_to_grs(bm,&bmheader);
 783
 784 #ifndef MACINTOSH
 785         if (palette) memcpy(palette,&bmheader.palette,sizeof(bmheader.palette));
 786 #else
 787 //      if (palette) memcpy(palette,&bmheader.palette, 768);                    // pal_entry is 4 bytes on mac
 788         if (palette) {
 789                 ubyte *c;
 790                 int i;
 791
 792                 c = palette;
 793                 for (i = 0; i < 256; i++) {
 794                         *c++ = bmheader.palette[i].r;
 795                         *c++ = bmheader.palette[i].g;
 796                         *c++ = bmheader.palette[i].b;
 797                 }
 798         }
 799 #endif
 800
 801         //Now do post-process if required
 802
 803         if (bitmap_type == BM_RGB15) {
 804                 ret = convert_rgb15(bm,&bmheader);
 805                 if (ret != IFF_NO_ERROR) goto done;
 806         }
 807
 808 done:
 809
 810         return ret;
 811
 812 }
 813
 814 //returns error codes - see IFF.H.  see GR.H for bitmap_type
 815 int iff_read_bitmap(char *ifilename,grs_bitmap *bm,int bitmap_type,ubyte *palette)
 816 {
 817         int ret;                        //return code
 818         FFILE ifile;
 819
 820         ret = open_fake_file(ifilename,&ifile);         //read in entire file
 821         if (ret != IFF_NO_ERROR) goto done;
 822
 823         bm->bm_data = NULL;
 824
 825         ret = iff_parse_bitmap(&ifile,bm,bitmap_type,palette,NULL);
 826
 827 done:
 828
 829         if (ifile.data) d_free(ifile.data);
 830
 831         close_fake_file(&ifile);
 832
 833         return ret;
 834
 835
 836 }
 837
 838 //like iff_read_bitmap(), but reads into a bitmap that already exists,
 839 //without allocating memory for the bitmap.
 840 int iff_read_into_bitmap(char *ifilename,grs_bitmap *bm,byte *palette)
 841 {
 842         int ret;                        //return code
 843         FFILE ifile;
 844
 845         ret = open_fake_file(ifilename,&ifile);         //read in entire file
 846         if (ret != IFF_NO_ERROR) goto done;
 847
 848         ret = iff_parse_bitmap(&ifile,bm,bm->bm_type,palette,NULL);
 849
 850 done:
 851
 852         if (ifile.data) d_free(ifile.data);
 853
 854         close_fake_file(&ifile);
 855
 856         return ret;
 857
 858
 859 }
 860
 861 #define BMHD_SIZE 20
 862
 863 int write_bmhd(FILE *ofile,iff_bitmap_header *bitmap_header)
 864 {
 865         put_sig(bmhd_sig,ofile);
 866         put_long((long) BMHD_SIZE,ofile);
 867
 868         put_word(bitmap_header->w,ofile);
 869         put_word(bitmap_header->h,ofile);
 870         put_word(bitmap_header->x,ofile);
 871         put_word(bitmap_header->y,ofile);
 872
 873         put_byte(bitmap_header->nplanes,ofile);
 874         put_byte(bitmap_header->masking,ofile);
 875         put_byte(bitmap_header->compression,ofile);
 876         put_byte(0,ofile);      /* pad */
 877
 878         put_word(bitmap_header->transparentcolor,ofile);
 879         put_byte(bitmap_header->xaspect,ofile);
 880         put_byte(bitmap_header->yaspect,ofile);
 881
 882         put_word(bitmap_header->pagewidth,ofile);
 883         put_word(bitmap_header->pageheight,ofile);
 884
 885         return IFF_NO_ERROR;
 886
 887 }
 888
 889 int write_pal(FILE *ofile,iff_bitmap_header *bitmap_header)
 890 {
 891         int     i;
 892
 893         int n_colors = 1<<bitmap_header->nplanes;
 894
 895         put_sig(cmap_sig,ofile);
 896 //      put_long(sizeof(pal_entry) * n_colors,ofile);
 897         put_long(3 * n_colors,ofile);
 898
 899 //printf("new write pal %d %d\n",3,n_colors);
 900
 901         for (i=0; i<256; i++) {
 902                 unsigned char r,g,b;
 903                 r = bitmap_header->palette[i].r * 4 + (bitmap_header->palette[i].r?3:0);
 904                 g = bitmap_header->palette[i].g * 4 + (bitmap_header->palette[i].g?3:0);
 905                 b = bitmap_header->palette[i].b * 4 + (bitmap_header->palette[i].b?3:0);
 906                 fputc(r,ofile);
 907                 fputc(g,ofile);
 908                 fputc(b,ofile);
 909         }
 910
 911 //printf("write pal %d %d\n",sizeof(pal_entry),n_colors);
 912 //      fwrite(bitmap_header->palette,sizeof(pal_entry),n_colors,ofile);
 913
 914         return IFF_NO_ERROR;
 915 }
 916
 917 int rle_span(ubyte *dest,ubyte *src,int len)
 918 {
 919         int n,lit_cnt,rep_cnt;
 920         ubyte last,*cnt_ptr,*dptr;
 921
 922         cnt_ptr=0;
 923
 924         dptr = dest;
 925
 926         last=src[0]; lit_cnt=1;
 927
 928         for (n=1;n<len;n++) {
 929
 930                 if (src[n] == last) {
 931
 932                         rep_cnt = 2;
 933
 934                         n++;
 935                         while (n<len && rep_cnt<128 && src[n]==last) {n++; rep_cnt++;}
 936
 937                         if (rep_cnt > 2 || lit_cnt < 2) {
 938
 939                                 if (lit_cnt > 1) {*cnt_ptr = lit_cnt-2; --dptr;}                //save old lit count
 940                                 *dptr++ = -(rep_cnt-1);
 941                                 *dptr++ = last;
 942                                 last = src[n];
 943                                 lit_cnt = (n<len)?1:0;
 944
 945                                 continue;               //go to next char
 946                         } else n--;
 947
 948                 }
 949
 950                 {
 951
 952                         if (lit_cnt==1) {
 953                                 cnt_ptr = dptr++;               //save place for count
 954                                 *dptr++=last;                   //store first char
 955                         }
 956
 957                         *dptr++ = last = src[n];
 958
 959                         if (lit_cnt == 127) {
 960                                 *cnt_ptr = lit_cnt;
 961                                 //cnt_ptr = dptr++;
 962                                 lit_cnt = 1;
 963                                 last = src[++n];
 964                         }
 965                         else lit_cnt++;
 966                 }
 967
 968
 969         }
 970
 971         if (lit_cnt==1) {
 972                 *dptr++ = 0;
 973                 *dptr++=last;                   //store first char
 974         }
 975         else if (lit_cnt > 1)
 976                 *cnt_ptr = lit_cnt-1;
 977
 978         return dptr-dest;
 979 }
 980
 981 #define EVEN(a) ((a+1)&0xfffffffel)
 982
 983 //returns length of chunk
 984 int write_body(FILE *ofile,iff_bitmap_header *bitmap_header,int compression_on)
 985 {
 986         int w=bitmap_header->w,h=bitmap_header->h;
 987         int y,odd=w&1;
 988         long len = EVEN(w) * h,newlen,total_len=0;
 989         ubyte *p=bitmap_header->raw_data,*new_span;
 990         long save_pos;
 991
 992         put_sig(body_sig,ofile);
 993         save_pos = ftell(ofile);
 994         put_long(len,ofile);
 995
 996     //if (! (new_span = d_malloc(bitmap_header->w+(bitmap_header->w/128+2)*2))) return IFF_NO_MEM;
 997     MALLOC( new_span, ubyte, bitmap_header->w + (bitmap_header->w/128+2)*2);
 998     if (new_span == NULL) return IFF_NO_MEM;
 999
1000         for (y=bitmap_header->h;y--;) {
1001
1002                 if (compression_on) {
1003                         total_len += newlen = rle_span(new_span,p,bitmap_header->w+odd);
1004                         fwrite(new_span,newlen,1,ofile);
1005                 }
1006                 else
1007                         fwrite(p,bitmap_header->w+odd,1,ofile);
1008
1009                 p+=bitmap_header->row_size;     //bitmap_header->w;
1010         }
1011
1012         if (compression_on) {           //write actual data length
1013                 Assert(fseek(ofile,save_pos,SEEK_SET)==0);
1014                 put_long(total_len,ofile);
1015                 Assert(fseek(ofile,total_len,SEEK_CUR)==0);
1016                 if (total_len&1) fputc(0,ofile);                //pad to even
1017         }
1018
1019         d_free(new_span);
1020
1021         return ((compression_on) ? (EVEN(total_len)+8) : (len+8));
1022
1023 }
1024
1025 #if WRITE_TINY
1026 //write a small representation of a bitmap. returns size
1027 int write_tiny(CFILE *ofile,iff_bitmap_header *bitmap_header,int compression_on)
1028 {
1029         int skip;
1030         int new_w,new_h;
1031         int len,total_len=0,newlen;
1032         int x,y,xofs,odd;
1033         ubyte *p = bitmap_header->raw_data;
1034         ubyte tspan[80],new_span[80*2];
1035         long save_pos;
1036
1037         skip = max((bitmap_header->w+79)/80,(bitmap_header->h+63)/64);
1038
1039         new_w = bitmap_header->w / skip;
1040         new_h = bitmap_header->h / skip;
1041
1042         odd = new_w & 1;
1043
1044         len = new_w * new_h + 4;
1045
1046         put_sig(tiny_sig,ofile);
1047         save_pos = cftell(ofile);
1048         put_long(EVEN(len),ofile);
1049
1050         put_word(new_w,ofile);
1051         put_word(new_h,ofile);
1052
1053         for (y=0;y<new_h;y++) {
1054                 for (x=xofs=0;x<new_w;x++,xofs+=skip)
1055                         tspan[x] = p[xofs];
1056
1057                 if (compression_on) {
1058                         total_len += newlen = rle_span(new_span,tspan,new_w+odd);
1059                         fwrite(new_span,newlen,1,ofile);
1060                 }
1061                 else
1062                         fwrite(p,new_w+odd,1,ofile);
1063
1064                 p += skip * bitmap_header->row_size;            //bitmap_header->w;
1065
1066         }
1067
1068         if (compression_on) {
1069                 Assert(cfseek(ofile,save_pos,SEEK_SET)==0);
1070                 put_long(4+total_len,ofile);
1071                 Assert(cfseek(ofile,4+total_len,SEEK_CUR)==0);
1072                 if (total_len&1) cfputc(0,ofile);               //pad to even
1073         }
1074
1075         return ((compression_on) ? (EVEN(total_len)+8+4) : (len+8));
1076 }
1077 #endif
1078
1079 int write_pbm(FILE *ofile,iff_bitmap_header *bitmap_header,int compression_on)                  /* writes a pbm iff file */
1080 {
1081         int ret;
1082         long raw_size = EVEN(bitmap_header->w) * bitmap_header->h;
1083         long body_size,tiny_size,pbm_size = 4 + BMHD_SIZE + 8 + EVEN(raw_size) + sizeof(pal_entry)*(1<<bitmap_header->nplanes)+8;
1084         long save_pos;
1085
1086 //printf("write_pbm\n");
1087
1088         put_sig(form_sig,ofile);
1089         save_pos = ftell(ofile);
1090         put_long(pbm_size+8,ofile);
1091         put_sig(pbm_sig,ofile);
1092
1093         ret = write_bmhd(ofile,bitmap_header);
1094         if (ret != IFF_NO_ERROR) return ret;
1095
1096         ret = write_pal(ofile,bitmap_header);
1097         if (ret != IFF_NO_ERROR) return ret;
1098
1099 #if WRITE_TINY
1100         tiny_size = write_tiny(ofile,bitmap_header,compression_on);
1101 #else
1102         tiny_size = 0;
1103 #endif
1104
1105         body_size = write_body(ofile,bitmap_header,compression_on);
1106
1107         pbm_size = 4 + BMHD_SIZE + body_size + tiny_size + sizeof(pal_entry)*(1<<bitmap_header->nplanes)+8;
1108
1109         Assert(fseek(ofile,save_pos,SEEK_SET)==0);
1110         put_long(pbm_size+8,ofile);
1111         Assert(fseek(ofile,pbm_size+8,SEEK_CUR)==0);
1112
1113         return ret;
1114
1115 }
1116
1117 //writes an IFF file from a grs_bitmap structure. writes palette if not null
1118 //returns error codes - see IFF.H.
1119 int iff_write_bitmap(char *ofilename,grs_bitmap *bm,ubyte *palette)
1120 {
1121         FILE *ofile;
1122         iff_bitmap_header bmheader;
1123         int ret;
1124         int compression_on;
1125
1126         if (bm->bm_type == BM_RGB15) return IFF_BAD_BM_TYPE;
1127
1128 #if COMPRESS
1129         compression_on = (bm->bm_w>=MIN_COMPRESS_WIDTH);
1130 #else
1131         compression_on = 0;
1132 #endif
1133
1134         //fill in values in bmheader
1135
1136         bmheader.x = bmheader.y = 0;
1137         bmheader.w = bm->bm_w;
1138         bmheader.h = bm->bm_h;
1139         bmheader.type = TYPE_PBM;
1140         bmheader.transparentcolor = iff_transparent_color;
1141         bmheader.pagewidth = bm->bm_w;  //I don't think it matters what I write
1142         bmheader.pageheight = bm->bm_h;
1143         bmheader.nplanes = 8;
1144         bmheader.masking = mskNone;
1145         if (iff_has_transparency)       {
1146                  bmheader.masking |= mskHasTransparentColor;
1147         }
1148         bmheader.compression = (compression_on?cmpByteRun1:cmpNone);
1149
1150         bmheader.xaspect = bmheader.yaspect = 1;        //I don't think it matters what I write
1151         bmheader.raw_data = bm->bm_data;
1152         bmheader.row_size = bm->bm_rowsize;
1153
1154         if (palette) memcpy(&bmheader.palette,palette,256*3);
1155
1156         //open file and write
1157
1158         if ((ofile = fopen(ofilename,"wb")) == NULL) {ret=IFF_NO_FILE; goto done;}
1159
1160         ret = write_pbm(ofile,&bmheader,compression_on);
1161
1162 done:
1163
1164         fclose(ofile);
1165
1166         return ret;
1167 }
1168
1169 //read in many brushes.  fills in array of pointers, and n_bitmaps.
1170 //returns iff error codes
1171 int iff_read_animbrush(char *ifilename,grs_bitmap **bm_list,int max_bitmaps,int *n_bitmaps,ubyte *palette)
1172 {
1173         int ret;                        //return code
1174         FFILE ifile;
1175         iff_bitmap_header bmheader;
1176         long sig,form_len;
1177         long form_type;
1178
1179         *n_bitmaps=0;
1180
1181         ret = open_fake_file(ifilename,&ifile);         //read in entire file
1182         if (ret != IFF_NO_ERROR) goto done;
1183
1184         bmheader.raw_data = NULL;
1185
1186         sig=get_sig(&ifile);
1187         form_len = get_long(&ifile);
1188
1189         if (sig != form_sig) {
1190                 ret = IFF_NOT_IFF;
1191                 goto done;
1192         }
1193
1194         form_type = get_sig(&ifile);
1195
1196         if ((form_type == pbm_sig) || (form_type == ilbm_sig))
1197                 ret = IFF_FORM_BITMAP;
1198         else if (form_type == anim_sig) {
1199                 int anim_end = ifile.position + form_len - 4;
1200
1201                 while (ifile.position < anim_end && *n_bitmaps < max_bitmaps) {
1202
1203                         grs_bitmap *prev_bm;
1204
1205                         prev_bm = *n_bitmaps>0?bm_list[*n_bitmaps-1]:NULL;
1206
1207                    MALLOC(bm_list[*n_bitmaps] , grs_bitmap, 1 );
1208
1209                         bm_list[*n_bitmaps]->bm_data = NULL;
1210
1211                         ret = iff_parse_bitmap(&ifile,bm_list[*n_bitmaps],form_type,*n_bitmaps>0?NULL:palette,prev_bm);
1212
1213                         if (ret != IFF_NO_ERROR)
1214                                 goto done;
1215
1216                         (*n_bitmaps)++;
1217                 }
1218
1219                 if (ifile.position < anim_end)  //ran out of room
1220                         ret = IFF_TOO_MANY_BMS;
1221
1222         }
1223         else
1224                 ret = IFF_UNKNOWN_FORM;
1225
1226 done:
1227
1228         close_fake_file(&ifile);
1229
1230         return ret;
1231
1232 }
1233
1234 //text for error messges
1235 char error_messages[] = {
1236         "No error.\0"
1237         "Not enough mem for loading or processing bitmap.\0"
1238         "IFF file has unknown FORM type.\0"
1239         "Not an IFF file.\0"
1240         "Cannot open file.\0"
1241         "Tried to save invalid type, like BM_RGB15.\0"
1242         "Bad data in file.\0"
1243         "ANIM file cannot be loaded with normal bitmap loader.\0"
1244         "Normal bitmap file cannot be loaded with anim loader.\0"
1245         "Array not big enough on anim brush read.\0"
1246         "Unknown mask type in bitmap header.\0"
1247         "Error reading file.\0"
1248 };
1249
1250
1251 //function to return pointer to error message
1252 char *iff_errormsg(int error_number)
1253 {
1254         char *p = error_messages;
1255
1256         while (error_number--) {
1257
1258                 if (!p) return NULL;
1259
1260                 p += strlen(p)+1;
1261
1262         }
1263
1264         return p;
1265
1266 }
1267
1268