Las librerías son muy importantes en la correcta programación de sistemas complejos. En el Amiga, por supuesto, el dominio de su programación pasa por la correcta utilización de las librerías propias o del sistema.

A continuación, los listados de los programas. El último de este capítulo se
publicará en otro número, por falta de espacio físico para más listados.
/*****************************************************************
 FICHERO .H: ilbmdefs.h
DESCRIPCION: Definicion de estructuras para compilacion de
             funciones.
DESARROLLO : 15-06-92 - Creacion (V. Santos)
*****************************************************************/
/* MACRO PARA IDENTIFICADORES DE TIPO, SUBTIPO Y CHUNKS ========*/
#define MakeID(a,b,c,d) ((LONG)(a)<<24L|(LONG)(b)<<16L|(c)<<8|(d))
/* IDENTIFICADORES DE TIPO Y SUBTIPO ===========================*/
#define FORM  MakeID('F','O','R','M')
#define ILBM  MakeID('I','L','B','M')
/* IDENTIFICADORES DE CHUNK ====================================*/
#define BMHD  MakeID('B','M','H','D')
#define CAMG  MakeID('C','A','M','G')
#define CMAP  MakeID('C','M','A','P')
#define BODY  MakeID('B','O','D','Y')
/* MODELO DE ESTRUCTURA DE CABECERA DE FICHERO =================*/
struct IFFHead {
          LONG typeID;
          LONG size;
          LONG subtypeID;
          };
/* MODELO DE ESTRUCTURA DE CABECERA DE CHUNK ===================*/
struct ChunkHead {
          LONG ckID;
          LONG ckSize;
          };
/* MODELO DE ESTRUCTURA DE CHUNK BMHD ==========================*/
struct BitMapHeader {
          UWORD w,h;
          WORD x,y;
          UBYTE nPlanes,masking,compression,pad1;
          BYTE xAspect,yAspect;
          WORD pageWidth,pageHeight;
          };
/* Relacion de aspecto horizontal/vertical segun especificaciones
 de Electronic Arts. Las siguientes definiciones han sido
extraidas de la documentacion publicada en el "RKM:Includes &
Autodocs" y son validad para graficos NTSC.
 Para graficos PAL no hay documentacion oficial (que yo sepa) y
los programas que trabajan en este modo no siguen un mismo
criterio.
 Ej: Deluxe Paint III utiliza una relacion de aspecto 1:1 para
graficos en 320x256. Deluxe Photolab, también de Electronic
Arts, calcula su propia relacion (163:154 para 320x256).
 Como DPaintIII es el mas popular, aqui he decidido seguir sus
normas utilizando la relacion 1:1 para graficos PAL. */
/* NTSC */
#define X_ASP_320x200    10
#define X_ASP_320x400    20
#define X_ASP_640x200    5
#define X_ASP_640x400    10
#define Y_ASP_TODOS      11
/* PAL  */
#define XY_ASP_PAL       1
/* MODELO DE ESTRUCTURA DE REGISTRO DE COLOR DE CHUNK CMAP ====*/
struct RegColor {
          UBYTE r,g,b;
          };
/* tamano de registro de color segun especificaciones de
Electronic Arts (utilizar esta definicion en lugar de
"sizeof(stuct RegColor)" */
#define SIZEREGCOLOR    3
/* mascara para escritura de datos */
#define COLORMASK    0xF0
/* FIN DE ilbmdefs.h ********************************************
//***************************************************************
     MODULO : ilbmread.c
DESCRIPCION : funciones para lectura de ficheros IFF-ILBM.
 DESARROLLO : 15-06-92 - Creacion (V. Santos)
****************************************************************/
/* FICHEROS DE CABECERA =======================================*/
#include <exec/types.h>
#include <exec/memory.h>
#incluse <graphics/gfx.h>
#include <graphics/view.h>
#include <libraries/dosextens.h>
#include "ilbmdefs.h"
/* DEFINICIONES================================================*/
/* macros para descompresion */
#define GetByte()    (*fuente++)
#define PutByte(dato) (*destino++=(dato))
/* GLOBALES====================================================*/
/* prototipos */
LONG checkilbm_c(struct FileHandle *);
struct BitMapHeader *getbmheader_c(struct FileHandle *,
                     struct BitMapHeader*);
LONG getgfxmode_c(struct FileHandle *);
LONG getcolmap_c(struct FileHandle *, struct BitMap *,
UBYTE,UBYTE);
BOOL findchunk(struct FileHandle *,struct ChunkeHead *);
BOOL unpackbr1(BYTE **,BYTE **,LONG);
/* FUNCIONES DE LIBRERIA =====================================*/
/* checkilbm_c()------------------------------------------------
Descripcion: comprueba si el fichero es IFF del subtipo ILBM
Argumentos : puntero a fichero.
Retorno    : tamano total si es IFF-ILBM, NULL si no lo es o
             error de lectura
--------------------------------------------------------------*/
LONG checkilbm_c(f)
struct FileHandle *f;
  {
  struct IFFHead iffh;    /* cabecera de fichero */
  LONG n;    /* comprobacion de lectura */
  if((n = Read((BPTR)f,(BYTE *)&iffh;, 12))!= 12)
    return(NULL);
  if(iffh.typeIDE == FORM)
    {
    if(iffh.subtypeID == ILBM)
      return(iffh.size);
    else
      return(NULL);
    }
  else
    return(NULL);
  }
/* getbmheader_c() --------------------------------------------
Descripcion : lee datos de BMHD.
Argumentos  : puntero a fichero.
              direccion de escritura de modelo BitMapHeader
Retorno     : puntero a estructura BitMapHeader ya inicializada
              o NULL si error de lectura o chunk no encontrado.
-------------------------------------------------------------*/
struct BitMapHeader *getbmheader_c(f,bmhd)
struct FileHandle *f;
struct BitMapHeader *bmhd;
  {
  struct ChunkHead ckh;   /* cabecera de chunk */
  LONG n;    /* comprobacion de lectura */
  BOOL encontrado = TRUE;    /* indicador */
  /* buscar chunk */
  ckh.ckID = BMHD;
  if((encontrado = findchunk(f,&ckh;)) == FALSE)
    return(NULL);
  /* leer datos */
  if((n = Read((BPTR)f, (BYTE *)nmhd,ckh.ckSize)) != 20)
    return(NULL);
  return(bmhd);
  }
/* getgfxmode_c()--------------------------------------------
Descripcion : lee modo grafico en CAMG.
Argumentos  : puntero a fichero.
Retorno     : modo grafico o NULL si chunk no encontrado o
              error de lectura.
-----------------------------------------------------------*/
LONG getgfxmode_c(f)
struct FileHandle *f;
  {
  struct ChunkHead ckh;    /* cabecera de chunk */
  ULONG gmodo;    /* modo grafico */
  LONG n;    /* comprobacion de lectura */
  BOOL encontrado = TRUE;    /* indicador */
  ckh.ckID = CAMG;
  if((encontrado = findchunk(f,&ckh;)) == FALSE)
    return(NULL);
  if((n = Read((BPTR)f,(BYTE *)&gmodo;,ckh.ckSize))!=4)
    return(NULL);
  return(gmodo);
  }
/* getcolmap_c()---------------------------------------------
Descripcion : lee paleta de colores convirtiendo de formato
              ILBM-CMAP (0xR0, 0xG0, 0xB0) a Amiga-CMap
              (0x0RGB).
Argumentos  : puntero a fichero,
              direccion de array para contener colores,
              numero de planos de bits.
Retorno     : numero de colores o 0 si chunk no encontrado o
              error de lectura
-----------------------------------------------------------*/
LONG getcolmap_c(f, colores, nplanos)
struct FileHandle *f;
UWORD *colores;
UBYTE nplanos;
  {
  struct ChunkHead ckh;    /* cabecera de chunk */
  struct RegColor rc;    /* registros en formato ILBM-CMAP */
  LONG numrc;    /* numero de registros de color */
  LONG n;    /* comprobacion de lectura */
  WORD i;    /* control de bucle de lectura */
  BOOL encontrado = TRUE; /* indicador */
  ckh.ckID = CMAP;
  if((encontrado = findchunk(f,&ckh;)) == FALSE)
    return(NULL);
  /* averiguar numero de registros de color */
  numrc = (((ckh.ckSize >> nplanos) & 1)<< nplanos);
  /* leer datos en formato ILBM... */
  for(i = 0;i < numrc;i++)
    {
      if((n = Read((BPTR)f,(BYTE *)&rc;, SIZEREGCOLOR)) !=
SIZEREGCOLOR)
return(NULL);
   /* ...convirtiendo a formato Amiga */
   *colores++ = ((rc.r << 4) + (rc.g) + (rc.b >> 4));
   }
  return(numrc);
  }
/* displaydata_c()--------------------------------------------
Descripcion : lee y visualiza datos graficos de BODY. SI estos
              estan comprimidos llama a su funcion auxiliar
              "unpackbr1()".
Argumentos  : puntero a fichero,
               direccion del BitMap,
               tipo de mascara (para esta version siempre 0),
               tipo de compresion (no comp = 0, ByteRun1 = 1).
Retorno     : bytes leidos si no hay errores, NULL si chunk no
              encontrado,
              memoria insuficiente, error en reserva, error en
              descompresion o error en lectura.
-----------------------------------------------------------*/
LONG displaydata_c(f, bmap, mask, comp)
struct FileHnadle *f;
struct BitMap *bmap;
UBYTE mask, comp;
  {
  struct ChunkHead ckh;   /* cabecera de chunk */
  ULONG memlibre;    /* comprobacion de memoria */
  BYTE *bufmem, *memdirec;    /* memoria para datos */
  BYTE *planos[6];    /* copia de planos de bits */
  LONG bytesfila;    /* num de bytes por fila */
  LONG n;    /* comprobacion de lectura */
  WORD i,j;    /* control de bucles */
  BOOL encontrado = TRUE;    /* indicador */
  BOOL nodesc = FALSE;    /* error de descompresion */
  ckh.ckID = BODY;
  iff((encontrado = findchunk(f, &ckh;)) == FALSE)
    return(NULL);
  /* comprobar si hay memoira suficiente y
si la hay reservar */
  if((memlibre = AvailMem(MEMF_PUBLIC)) < ckh,ckSize)
    return(NULL);
  if((bufmem = (BYTE *)AllocMem(ckh.ckSize, MEMF_PUBLIC))
== NULL)
    return(NULL);
  memdirec = bufmen;
  /* pasar datos a memoria */
  if((n = Read((BPTR)f, bufmem, ckh.ckSize)) !=ckh.ckSize)
    {
    FreeMem(memdirec,ckh.ckSize);
    return(NULL);
    }
  /* sacar copias de planos de bits */
  for(j = 0;j < bmap->Depth; j++)
    planos[j] = (BYTE *)bmap->Planes[j];
  /* visualizar */
  bytesfila = bmap->BytesPerRow;
  for(i = bmap->Rows; i > 0;i--)
    {
    for(j = 0;j < bmap->Depth; j++)
      {
      if(comp == 0)
        {
        CopyMem((APTR)bufmem,(APTR)planos[j], bytesfila):
        bufmem    += bytesfila;
        planos[j] += bytesfila;
        }
      else
        {
        if((nodesc = unpackbr1(&bufmem;,&planos;[j], bytesfila))
== TRUE)
          {
          FreeMem(memdirec, ckh,ckSize);
          return(NULL);
          }
        }
      }
    }
  /* liberar memoria */
  FreeMem(memdirec, ckh.ckSize);
  return(ckh.ckSize);
  }
/* FUNCIONES AUXILIARES (USO INTERNO) =======================*/
/* findchunk()-------------------------------------------------
Descripcion : funcion auxiliar para todas las de lectura. Busca
              chunks en el fichero sin importa el orden en que
              se encuentren.
Argumentos  : puntero a fichero,
              direccion de estructura de modelo ChunkHead.
Retorno     : TRUE si chunk encontrado, FALSE si no o error en
              lectura.
------------------------------------------------------------*/
BOOL findchunk(f,ckh)
struct FileHandle *f;
struct ChunkHead *ckh;
  {
  struct ChunkHead chunk;    /* para lectura de cabeceras */
  LONG n;    /* comprobacion de lectura */
  /* buscar chunks desde inicio de fichero (saltando FORM) */
  Seek((BPTR)f, 12, OFFSET_BEGINNING);
  while(! existe)
    {
    if((n = Read((BPTR)f, (BYTE *)&chunk;,8))!=8)
      break;
    if(chunk.ckID == ckh->ckID)
      {
      ckh->ckSize = chunk.ckSize;
      existe  = TRUE;
      }
    else
      {
      /* saltar chunks no buscados o desconocidos
         (si tamaño impar saltar 1 byte mas)*/
      if((chunk.ckSize) & 1)
        chunk.ckSize += 1;
        Seek((BPTR)f,chunk.ckSize, OFFSET_CURRENT);
        continue;
        }
     }
   return(existe);
   }
/* unpackbr1()----------------------------------------------
Descricion : Funcion auxiliar de "displaydata_c", descompri-
             me datos en formato ByteRun1.
Argumentos : puntero a puntero copias de planos de bites,
             numero de bytes por fila en cada plano.
Retorno    : FALSE si no hay fallos, TRUE si numero de bytes
             resultantes de descompresion mayor que
             numero de bytes por fila.
Nota       : Adaptacion de la funcion "UnPackRow()" de
             Electronic Arts, original de Jerry Morrison y
             Steve Shaw y puesta en el Dominio Publico
---------------------------------------------------------*/
BOOL unpackbr1(buf, planos, nbytes)
BYTE **buf, **planos;
LONG nbytes;
  {
  register BYTE *fuente = *buf;    /* datos en nuffer */
  register BYTE *destino = *planos;    /* copias de planos de bits */
  register WORD control;    /* byte de control */
  register BYTE dato;    /* byte de dato grafico */
  LONG numb = 0;    /* control de bytes por fila */
  WORD nohacernada = -128;    /* esta claro, no? */
  BOOL error = FALSE;    /* asumir no errores */
  /* iniciar descompresion */
  do
   {
   if((control = GetByte()) > 0)    /* control entre 0 y 128 */
     {
     control + = 1;
     if((numb += control) > nbytes)    /* comprobar bytes por fila */
         error = TRUE;
       else
         {
         do
          {
          PutByte(GetByte());    /* pasar bytes no empaquetados */
          } while(--control > 0);
        }
      }
    else
      {
      if(control != nohacernada)    /* o sea, entre -1 y -127 */
        {
        control = -control + 1;
        if((numb += control) > nbytes)
           error = TRUE;
         else
           {
           dato = GetByte();
           do
            {
            PutByte(dato):    /* pasar byte empaquetado */
            } while(--control > 0);
          }
        }
      } while(numb < nbytes);
   /* actualizar punteros */
   *buf    = fuente;
   *planos = destino;
   return(error);
   }
/* FIN DE ilbmread.c ******************************************/