home *** CD-ROM | disk | FTP | other *** search
/ Club Amiga de Montreal - CAM / CAM_CD_1.iso / files / 564a.lha / 24BitTools / IFF24To8 / readilbm.c < prev    next >
C/C++ Source or Header  |  1991-10-28  |  7KB  |  234 lines
  1. #include <functions.h>
  2. #include "iff.h"
  3.  
  4. extern void *IntuitionBase,*GfxBase,*DiskfontBase;
  5.  
  6. /* READILBM.C : based on NewZAP's READILBM.C
  7.                 (c) 1986,1990,1991 Dallas J. Hodgson
  8.  
  9.                 Loads bitmaps into MEMF_PUBLIC
  10.  */
  11.  
  12. LoadMode Mode;
  13. unsigned char *pdiskptr;
  14.  
  15. /************************************************************************
  16. *                                                                       *
  17. *    Routine name(s) : ReadILBM()                                       *
  18. *    Author          : D. John Hodgson                                  *
  19. *    Environment     : Aztec "C", default                               *
  20. *                                                                       *
  21. *    ReadILBM attempts to read an IFF file into an user-supplied        *
  22. *    bitmap. Returns FALSE if successful. Brushes supported.            *
  23. *                                                                       *
  24. *    OPTIONS : Filespec reflects user-supplied pointer to IFF file in   *
  25. *              RAM if mode argument is non-zero. Otherwise, disk.       *
  26. *                                                                       *
  27. *    LIMITATIONS : Bare-bones ILBM; no CATS/LISTS/PROPS.                *
  28. *                  All other graphics (compressed or not) supported.    *
  29. ************************************************************************/
  30.  
  31. BPTR OpenNEW(unsigned char *name,long accessMode)
  32. {
  33.   if (Mode==DISK_MODE) return(Open((char *)name,accessMode));
  34.  
  35.   pdiskptr=name; /* initialize pseudo-disk RAM ptr */ 
  36.   return((BPTR)pdiskptr);
  37. }
  38.  
  39. long ReadNEW(BPTR file,char *buffer,long length)
  40. {
  41.   if (Mode==DISK_MODE) return(Read(file,buffer,length));
  42.  
  43.   movmem(pdiskptr,buffer,(unsigned int)length);
  44.   pdiskptr+=length;
  45.  
  46.   return(length);
  47. }
  48.  
  49. long SeekNEW(BPTR file,long position,long tmode)
  50. {
  51.   if (Mode==DISK_MODE) return(Seek(file,position,tmode));
  52.  
  53.   /* Note : RAM seek only supports one mode : OFFSET_CURRENT! */
  54.   if (tmode!=OFFSET_CURRENT) return(BAD_MODE);
  55.     
  56.   pdiskptr+=position;
  57.  
  58.   return((long)pdiskptr-position); /* Seek() returns previous position! */
  59. } 
  60.  
  61. void CloseNEW(BPTR file)
  62. {
  63.   if (Mode==DISK_MODE) Close(file);
  64. }
  65.  
  66. ReadILBM(char *fspec,LoadMode mode,struct PicMap *picmap)
  67. {
  68.   BPTR fp;
  69.   Chunk header;
  70.   BitMapHeader bmhd;
  71.   unsigned char *tmp,*bufstart,*sourcebuf;
  72.   UWORD i,color;
  73.   long id;
  74.  
  75.   Mode=mode; 
  76.   memset(picmap,0,sizeof(*picmap));
  77.  
  78.   if (!(fp=OpenNEW((unsigned char *)fspec,MODE_OLDFILE))) return(DISK_ERR);
  79.  
  80.   SafeRead(fp,&header,(long)sizeof(header));
  81.   if (header.ckID!=ID_FORM) { CloseNEW(fp); return(IFF_ERR); }
  82.  
  83.   SafeRead(fp,&id,(long)sizeof(id));
  84.   if (id!=ID_ILBM) { CloseNEW(fp); return(IFF_ERR); }
  85.  
  86.   for (;;) {
  87.     SafeRead(fp,&header,(long)sizeof(header));
  88.  
  89.     if (header.ckID==ID_BODY) break;
  90.  
  91.     switch(header.ckID) {
  92.       case ID_BMHD: SafeRead(fp,&bmhd,(long)sizeof(bmhd));
  93.  
  94.                     /* force WORD boundary for all pics */
  95.                     bmhd.w=(bmhd.w + 0xf) & 0xfff0;
  96.  
  97.                     break;
  98.  
  99.       case ID_CMAP: tmp=picmap->palette;
  100.                     SafeRead(fp,tmp,(long)header.ckSize);
  101.  
  102.                     for (i=0;i<header.ckSize/3;i++) {
  103.  
  104.                       color = (*tmp++ & 0xf0) << 4;
  105.                       color |= (*tmp++ & 0xf0);
  106.                       color |= *tmp++ >> 4;
  107.  
  108.                       picmap->colormap[i]=color;
  109.                     }
  110.  
  111.                     break;    
  112.  
  113.       case ID_CAMG: SafeRead(fp,&picmap->ViewModes,(long)header.ckSize);
  114.                     break;
  115.  
  116.       default:      SeekNEW(fp,ROUNDODDUP(header.ckSize),OFFSET_CURRENT);
  117.     }
  118.   }
  119.  
  120.   /* make some forced assumptions if CAMG chunk unavailable */
  121.  
  122.   if (!picmap->ViewModes) {
  123.     if (bmhd.w>LOWIDTH) picmap->ViewModes=HIRES;
  124.     if (bmhd.h>LOHEIGHT) picmap->ViewModes|=LACE;
  125.   }
  126.  
  127.   /* Read planes into RAM for ease of decompression */
  128.  
  129.   if (Mode==RAM_MODE) sourcebuf=bufstart=pdiskptr;  /* memory-resident IFF? */
  130.   else { /* disk-resident IFF? */
  131.     if (!(sourcebuf=bufstart=AllocMem((long)header.ckSize,MEMF_PUBLIC)))
  132.        return(OUT_OF_MEM);
  133.     SafeRead(fp,sourcebuf,(long)header.ckSize); CloseNEW(fp);  
  134.   }
  135.  
  136.   InitBitMap(&picmap->BitMap,(long)bmhd.nPlanes,(long)bmhd.w,(long)bmhd.h);
  137.  
  138.   /* note that we're not necessarily allocating CHIP_MEM here! */
  139.  
  140.   for (i=0;i<bmhd.nPlanes;i++)
  141.     if (!(picmap->BitMap.Planes[i]=AllocMem(RASSIZE(bmhd.w,bmhd.h),MEMF_PUBLIC))) {
  142.       FreeBitMap(&picmap->BitMap);
  143.       FreeMem(bufstart,(long)header.ckSize);
  144.       return(OUT_OF_MEM);
  145.     }
  146.  
  147.   i=Expand(&bmhd,bufstart,&picmap->BitMap);
  148.  
  149.   if (Mode==DISK_MODE) FreeMem(bufstart,(long)header.ckSize);
  150.  
  151.   return(i); /* error if unpacking prob */
  152. }      
  153.  
  154. void FreeBitMap(struct BitMap *bitmap)
  155. {
  156.   short i;
  157.  
  158.   /* take into acct partially allocated maps (due to error) */
  159.  
  160.   for (i=0;i<bitmap->Depth;i++) {
  161.     if (bitmap->Planes[i]) FreeMem(
  162.        bitmap->Planes[i],bitmap->BytesPerRow*bitmap->Rows);
  163.   }
  164.  
  165.   memset(bitmap,0,sizeof(bitmap)); /* prevent dbl-dealloc errs */
  166. }
  167.  
  168. /* Fast line decompress/deinterleave : NEW VERSION */
  169.  
  170. Expand(BitMapHeader *bmhd,register unsigned char *sourcebuf,struct BitMap *bitmap)
  171. {
  172.   register char n,*destbuf; /* in order of preferred allocation */
  173.   register short plane,rowlen,rowbytes,i;
  174.   short planes=bmhd->nPlanes,maskplane = -1;
  175.  
  176.   /* This routine now supports mask (stencil) planes and brushes. The only
  177.      thing it doesn't support is "trimming" the right edge of brushes to
  178.      the background color if they're not exactly modulo 16 wide. DPaint III
  179.      doesn't bother either, if you try to load a brush as a screen. */
  180.  
  181.   rowlen=((bmhd->w +15) & 0xFFF0) >> 3; /* round widths up to word boundary */
  182.  
  183.   /* For deinterleaving purposes, decompress (but don't store)
  184.      any mask planes (if present). */
  185.  
  186.   if (bmhd->masking==mskHasMask) {
  187.     maskplane=planes;
  188.     planes++;
  189.   }
  190.  
  191.   for (i=0;i<bmhd->h;i++) /* process n lines/screen */
  192.     for (plane=0;plane<planes;plane++) { /* process n planes/line */
  193.  
  194.       if (plane!=maskplane) destbuf=(char *)(bitmap->Planes[plane])+rowlen*i;
  195.  
  196.       if (bmhd->compression==cmpByteRun1) { /* compressed screen? */
  197.         rowbytes=rowlen;
  198.  
  199.         while (rowbytes>0) { /* unpack until 1 scan-line complete */
  200.           n=*sourcebuf++; /* fetch block run marker */
  201.  
  202.           /* uncompressed block? copy n bytes verbatim */
  203.           if (n>=0) {
  204.             ++n;
  205.             if (plane!=maskplane) {
  206.               movmem(sourcebuf,destbuf,(unsigned int)n);
  207.               destbuf+=n;
  208.             }
  209.             rowbytes-=n; sourcebuf+=n;
  210.           }
  211.           else { /* compressed block? expand n duplicate bytes */
  212.             n=-n+1;
  213.             if (plane!=maskplane) {
  214.               memset(destbuf,(int)(*sourcebuf),(int)n);
  215.               destbuf+=n;
  216.             }
  217.             rowbytes -=n; sourcebuf++;
  218.           }
  219.  
  220.         } /* finish unpacking line */
  221.         if (rowbytes) return(EXPAND_ERR); /* shouldn't be any left over! */
  222.       }
  223.       else { /* uncompressed? just copy */
  224.         if (plane!=maskplane) {
  225.           movmem(sourcebuf,destbuf,(unsigned int)rowlen);
  226.           destbuf+=rowlen;
  227.         }
  228.         sourcebuf+=rowlen;
  229.       }
  230.     } /* finish interleaved planes, lines */
  231.  
  232.   return(0); /* good result! */
  233. }
  234.