Forum AmigaOne Zone

/* makeshape: program to create shapes: IFF loading part. */

#include <stdio.h>
#include <dos/dos.h>
#include <libraries/iffparse.h>
#include <exec/memory.h>
#include <datatypes/pictureclass.h>
#include <clib/dos_protos.h>
#include <clib/iffparse_protos.h>
#include <clib/exec_protos.h>
#include <clib/graphics_protos.h>

#include "IFFload.h"

/*======================================================================*
 *  depackbuffer: depack buffer into BitMap within ILBMInfo.
 *  Inputs: pointer to ILBMInfo, pointer to buffer
 *  Output: result
 *======================================================================*/
int depackbuffer(struct ILBMInfo *ii, BYTE *buffer)
{
   int result=-1;
   WORD row, plane, bpr;
   PLANEPTR planes[8];
   BYTE c, n;

   if (ii->bitmap = AllocBitMap(ii->width, ii->height, ii->depth, 0, NULL)) {
      for (plane = 0; plane < ii->depth; plane++)
         planes[plane] = ii->bitmap->Planes[plane];
      for (row = 0; row < ii->height; row++) {
         for (plane = 0; plane < ii->depth; plane++) {
            bpr = ii->bpr;
            if (ii->compression == cmpNone) {
               CopyMem(buffer, planes[plane], bpr);
               buffer += bpr;
               planes[plane] += bpr;
            }
            else if (ii->compression == cmpByteRun1) {
               while (bpr > 0) {
                  if ((c = *buffer++) >= 0) {
                     c++;
                     bpr -= c;
                     while (c-- > 0)
                        *planes[plane]++ = *buffer++;
                  }
                  else if (c != -128) {
                     c = -c + 1;
                     bpr -= c;
                     n = *buffer++;
                     while (c-- > 0)
                        *planes[plane]++ = n;
                  }
               }
            }
         }     
      }   
      result = 0;
   }
   return result;
}

/*======================================================================*
 *  readbody: alloc buffer then depack ILBM BODY into it.
 *  Inputs: pointer to ILBMInfo, pointer to IFFHandle.
 *  Output: result
 *======================================================================*/
int readbody(struct ILBMInfo *ii, struct IFFHandle *iff)
{
   struct ContextNode *cn;
   BYTE *buffer;
   int result=-1;
   
   if (cn = CurrentChunk(iff)) {
      if (buffer = AllocMem(cn->cn_Size, MEMF_PUBLIC)) {
         if (ReadChunkBytes(iff, buffer, cn->cn_Size) == cn->cn_Size) {
            result = depackbuffer(ii, buffer);
         }
         FreeMem(buffer, cn->cn_Size);   
      }
   }   
   return result;
}

/*======================================================================*
 *  storebmhd: copy contents of BMHD chunk into ILMBInfo.
 *  Inputs: pointer to ILBMInfo, pointer to BitMapHeader
 *  Output: none
 *======================================================================*/
void storebmhd(struct ILBMInfo *ii, struct BitMapHeader *bmhd)
{
   ii->width       = bmhd->bmh_Width;
   ii->height      = bmhd->bmh_Height;
   ii->depth       = bmhd->bmh_Depth;
   ii->bpr         = ROWBYTES(ii->width);
   ii->compression = bmhd->bmh_Compression;
}

/*======================================================================*
 *  storecmap: copy contents of CMAP chunk into ILBMInfo.
 *  Inputs: pointer to ILBMInfo, pointer to CMAP, size of CMAP chunk
 *  Output: result
 *======================================================================*/
int storecmap(struct ILBMInfo *ii, UBYTE *cmap, ULONG size)
{
   if (ii->cmap = AllocMem(size, MEMF_PUBLIC)) {
      CopyMem(cmap, ii->cmap, size);
      return 0;
   }
   return -1;
}

/*======================================================================*
 *  readilbm: store data from IFF ILBM file into ILBMInfo.
 *  Inputs: pointer to ILBMInfo, pointer to IFFHandle
 *  Output: result
 *======================================================================*/
int readilbm(struct ILBMInfo *ii, struct IFFHandle *iff)
{
   struct StoredProperty *sp;
   int result=-1;
   
   if (sp = FindProp(iff, ID_ILBM, ID_BMHD)) {
      storebmhd(ii, (struct BitMapHeader *)sp->sp_Data);
      if (sp = FindProp(iff, ID_ILBM, ID_CMAP)) {
         storecmap(ii, sp->sp_Data, sp->sp_Size);
      }
      result = readbody(ii, iff);
   }
   return result;
}

/*======================================================================*
 *  parseilbm: parse IFF ILBM file.
 *  Inputs: pointer to ILBMInfo, pointer to IFFHandle
 *  Output: result
 *======================================================================*/
int parseilbm(struct ILBMInfo *ii, struct IFFHandle *iff)
{
   int result;

   result  = PropChunk(iff, ID_ILBM, ID_BMHD);
   result |= PropChunk(iff, ID_ILBM, ID_CMAP);
   result |= StopChunk(iff, ID_ILBM, ID_BODY);
   if (result == 0 && ParseIFF(iff, IFFPARSE_SCAN) == 0) {
      result = readilbm(ii, iff);
   }
   return result;
}

/*======================================================================*
 *  openiff: begin transaction with IFF file and begin parsing.
 *  Inputs: pointer to ILBMInfo, pointer to IFFHandle
 *  Output: result
 *======================================================================*/
int openiff(struct ILBMInfo *ii, struct IFFHandle *iff)
{
   int result=-1;

   if (OpenIFF(iff, IFFF_READ) == 0) {
      result = parseilbm(ii, iff);
      CloseIFF(iff);
   }
   return result;
}

/*======================================================================*
 *  openilbm: open IFF file and store contents into ILBMInfo.
 *  Inputs: pointer to ILBMInfo, pointer to IFFHandle, name
 *  Output: result
 *======================================================================*/
int openilbm(struct ILBMInfo *ii, struct IFFHandle *iff, char *name)
{
   int result=-1;

   if (iff->iff_Stream = Open(name, MODE_OLDFILE)) {
      InitIFFasDOS(iff);
      result = openiff(ii, iff);
      Close(iff->iff_Stream);
   }
   return result;
}

/*======================================================================*
 *  fillilbminfo: fill ILBMInfo structure with data from IFF file.
 *  Inputs: pointer to ILBMInfo, name
 *  Output: result
 *======================================================================*/
int fillilbminfo(struct ILBMInfo *ii, char *name)
{
   struct IFFHandle *iff;
   int result=-1;

   if (iff = AllocIFF()) {
      result = openilbm(ii, iff, name);
      FreeIFF(iff);
   }   
   return result;
}

/*======================================================================*
 *  loadilbm: load IFF ILBM named name.
 *  Inputs: name
 *  Output: pointer to ILBMInfo
 *======================================================================*/
struct ILBMInfo *loadilbm(char *name)
{
   struct ILBMInfo *ii;
   
   if (ii = AllocMem(sizeof(struct ILBMInfo), MEMF_PUBLIC|MEMF_CLEAR)) {
      if (fillilbminfo(ii, name) == 0) {
         return ii;
      }
      FreeMem(ii, sizeof(struct ILBMInfo));
   }
   return NULL;
}