home *** CD-ROM | disk | FTP | other *** search
/ Meeting Pearls 3 / Meeting_Pearls_III.iso / Pearls / texmf / source / driver / util / iff / ilbm.h < prev    next >
C/C++ Source or Header  |  1993-02-27  |  11KB  |  312 lines
  1. /* 
  2.  *
  3.  * ilbm.h:    Definitions for IFFParse ILBM reader.
  4.  *
  5.  * 5/92
  6.  * 39.1 - 7/92 - added setcolors, interface change for loadcmap
  7.  * 39.5 - 11/92 - get rid of BytesPerRow macro which duplicated RowBytes
  8.  *                AND conflicted with a system structure member name.
  9.  *          Changed "BitsPerRow" macro to "RowBits" to match.
  10.  *                Also unconditionalized extern of GfxBase and IntuitionBase
  11.  */
  12.  
  13. #ifndef IFFP_ILBM_H
  14. #define IFFP_ILBM_H
  15.  
  16. #ifndef IFFP_IFF_H
  17. #include "iff.h"
  18. #endif
  19.  
  20. #ifndef INTUITION_INTUITION_H
  21. #include <intuition/intuition.h>
  22. #endif
  23. #ifndef GRAPHICS_VIDEOCONTROL_H
  24. #include <graphics/videocontrol.h>
  25. #endif
  26.  
  27. #ifndef NO_PROTOS
  28. #include <clib/graphics_protos.h>
  29. #include <clib/intuition_protos.h>
  30. #include <clib/alib_protos.h>
  31. #endif
  32.  
  33. extern struct IntuitionBase *IntuitionBase;
  34. extern struct GfxBase       *GfxBase;
  35.  
  36. #ifndef NO_SAS_PRAGMAS
  37. #include <pragmas/intuition_pragmas.h>
  38. #include <pragmas/graphics_pragmas.h>
  39. #endif
  40.  
  41. /*  IFF types we may encounter  */
  42. #define    ID_ILBM        MAKE_ID('I','L','B','M')
  43.  
  44. /* ILBM Chunk ID's we may encounter
  45.  * (see iffp/iff.h for some other generic chunks)
  46.  */
  47. #define    ID_BMHD        MAKE_ID('B','M','H','D')
  48. #define    ID_CMAP        MAKE_ID('C','M','A','P')
  49. #define    ID_CRNG        MAKE_ID('C','R','N','G')
  50. #define    ID_CCRT        MAKE_ID('C','C','R','T')
  51. #define    ID_GRAB        MAKE_ID('G','R','A','B')
  52. #define    ID_SPRT        MAKE_ID('S','P','R','T')
  53. #define    ID_DEST        MAKE_ID('D','E','S','T')
  54. #define    ID_CAMG        MAKE_ID('C','A','M','G')
  55.  
  56. /* Use this constant instead of sizeof(ColorRegister).
  57.  * ONLY VALID FOR size of color register AS STORED in ILBM.CMAP
  58.  */
  59. #define sizeofColorRegister  3
  60.  
  61.  
  62. typedef WORD Color4;   /* Amiga RAM version of a color-register,
  63.           * with 4 bits each RGB in low 12 bits.*/
  64.  
  65. typedef struct {
  66.     ULONG    r;
  67.     ULONG    g;
  68.     ULONG    b;
  69.     } Color32;
  70.  
  71. /* Maximum number of bitplanes storable in BitMap structure */
  72. #define MAXAMDEPTH 8
  73.  
  74. /* Use ViewPort->ColorMap.Count instead 
  75. #define MAXAMCOLORREG 32
  76. */
  77.  
  78. /* Maximum planes this code can save */
  79. #define MAXSAVEDEPTH 24
  80.  
  81. /* Convert image width to even number of BytesPerRow for ILBM save.
  82.  * Do NOT use this macro to determine the actual number of bytes per row
  83.  * in an Amiga BitMap.  Use BitMap->BytesPerRow for scan-line modulo.
  84.  * Use your screen or viewport width to determine width. Or under
  85.  * V39, use GetBitMapAttr().
  86.  */
  87. #define RowBytes(w)    ((((w) + 15) >> 4) << 1)
  88. #define RowBits(w)    ((((w) + 15) >> 4) << 4)
  89.  
  90. /* Flags that should be masked out of old 16-bit CAMG before save or use.
  91.  * Note that 32-bit mode id (non-zero high word) bits should not be twiddled
  92.  */
  93. #define BADFLAGS  (SPRITES|VP_HIDE|GENLOCK_AUDIO|GENLOCK_VIDEO)
  94. #define OLDCAMGMASK  (~BADFLAGS)
  95.  
  96.  
  97. /*  Masking techniques  */
  98. #define    mskNone            0
  99. #define    mskHasMask        1
  100. #define    mskHasTransparentColor    2
  101. #define    mskLasso        3
  102.  
  103. /* We plan to define this value, to mean that the BMHD.transparentColor
  104.  * variable contains a count of alpha channel planes which are stored
  105.  * in the BODY AFTER the image planes.  As always, the count of
  106.  * masking/alpha planes is not included in BMHD.nPlanes.
  107.  * If you have any comments or input, contact Chris Ludwig (CATS US).
  108.  */
  109. #define    mskHasAlpha        4
  110.  
  111.  
  112. /*  Compression techniques  */
  113. #define    cmpNone            0
  114. #define    cmpByteRun1        1
  115.  
  116.  
  117.  
  118. /* ---------- BitMapHeader ---------------------------------------------*/
  119. /*  Required Bitmap header (BMHD) structure describes an ILBM */
  120. typedef struct {
  121.     UWORD    w, h;        /* Width, height in pixels */
  122.     WORD    x, y;        /* x, y position for this bitmap  */
  123.     UBYTE    nPlanes;    /* # of planes (not including mask) */
  124.     UBYTE    masking;    /* a masking technique listed above */
  125.     UBYTE    compression;    /* cmpNone or cmpByteRun1 */
  126.     UBYTE    flags;        /* as defined or approved by Commodore */
  127.     UWORD    transparentColor;
  128.     UBYTE    xAspect, yAspect;
  129.     WORD    pageWidth, pageHeight;
  130. } BitMapHeader;
  131.  
  132. /* BMHD flags */
  133.  
  134. /* Advisory that 8 significant bits-per-gun have been stored in CMAP
  135.  * i.e. that the CMAP is definitely not 4-bit values shifted left.
  136.  * This bit will disable nibble examination by color loading routine.
  137.  */
  138. #define BMHDB_CMAPOK    7
  139. #define BMHDF_CMAPOK    (1 << BMHDB_CMAPOK)
  140.  
  141.  
  142. /* ---------- ColorRegister --------------------------------------------*/
  143. /* A CMAP chunk is a packed array of ColorRegisters (3 bytes each). */
  144. typedef struct {
  145.     UBYTE red, green, blue;   /* MUST be UBYTEs so ">> 4" won't sign extend.*/
  146.     } ColorRegister;
  147.  
  148. /* ---------- Point2D --------------------------------------------------*/
  149. /* A Point2D is stored in a GRAB chunk. */
  150. typedef struct {
  151.     WORD x, y;      /* coordinates (pixels) */
  152.     } Point2D;
  153.  
  154. /* ---------- DestMerge ------------------------------------------------*/
  155. /* A DestMerge is stored in a DEST chunk. */
  156. typedef struct {
  157.     UBYTE depth;   /* # bitplanes in the original source */
  158.     UBYTE pad1;      /* UNUSED; for consistency store 0 here */
  159.     UWORD planePick;   /* how to scatter source bitplanes into destination */
  160.     UWORD planeOnOff;   /* default bitplane data for planePick */
  161.     UWORD planeMask;   /* selects which bitplanes to store into */
  162.     } DestMerge;
  163.  
  164. /* ---------- SpritePrecedence -----------------------------------------*/
  165. /* A SpritePrecedence is stored in a SPRT chunk. */
  166. typedef UWORD SpritePrecedence;
  167.  
  168. /* ---------- Camg Amiga Viewport Mode Display ID ----------------------*/
  169. /* The CAMG chunk is used to store the Amiga display mode in which
  170.  * an ILBM is meant to be displayed.  This is very important, especially
  171.  * for special display modes such as HAM and HALFBRITE where the
  172.  * pixels are interpreted differently.
  173.  * Under V37 and higher, store a 32-bit Amiga DisplayID (aka. ModeID)
  174.  * in the ULONG ViewModes CAMG variable (from GetVPModeID(viewport)).
  175.  * Pre-V37, instead store the 16-bit viewport->Modes.
  176.  * See the current IFF manual for information on screening for bad CAMG
  177.  * chunks when interpreting a CAMG as a 32-bit DisplayID or 16-bit ViewMode.
  178.  * The chunk's content is declared as a ULONG.
  179.  */
  180. typedef struct {
  181.    ULONG ViewModes;
  182.    } CamgChunk;
  183.  
  184. /* ---------- CRange cycling chunk -------------------------------------*/
  185. #define RNG_NORATE  36   /* Dpaint uses this rate to mean non-active */
  186. /* A CRange is store in a CRNG chunk. */
  187. typedef struct {
  188.     WORD  pad1;              /* reserved for future use; store 0 here */
  189.     WORD  rate;      /* 60/sec=16384, 30/sec=8192, 1/sec=16384/60=273 */
  190.     WORD  active;     /* bit0 set = active, bit 1 set = reverse */
  191.     UBYTE low, high;   /* lower and upper color registers selected */
  192.     } CRange;
  193.  
  194. /* ---------- Ccrt (Graphicraft) cycling chunk -------------------------*/
  195. /* A Ccrt is stored in a CCRT chunk. */
  196. typedef struct {
  197.    WORD  direction;  /* 0=don't cycle, 1=forward, -1=backwards */
  198.    UBYTE start;      /* range lower */
  199.    UBYTE end;        /* range upper */
  200.    LONG  seconds;    /* seconds between cycling */
  201.    LONG  microseconds; /* msecs between cycling */
  202.    WORD  pad;        /* future exp - store 0 here */
  203.    } CcrtChunk;
  204.  
  205. /* If you are writing all of your chunks by hand,
  206.  * you can use these macros for these simple chunks.
  207.  */
  208. #define putbmhd(iff, bmHdr)  \
  209.     PutCk(iff, ID_BMHD, sizeof(BitMapHeader), (BYTE *)bmHdr)
  210. #define putgrab(iff, point2D)  \
  211.     PutCk(iff, ID_GRAB, sizeof(Point2D), (BYTE *)point2D)
  212. #define putdest(iff, destMerge)  \
  213.     PutCk(iff, ID_DEST, sizeof(DestMerge), (BYTE *)destMerge)
  214. #define putsprt(iff, spritePrec)  \
  215.     PutCk(iff, ID_SPRT, sizeof(SpritePrecedence), (BYTE *)spritePrec)
  216. #define putcamg(iff, camg)  \
  217.     PutCk(iff, ID_CAMG, sizeof(CamgChunk),(BYTE *)camg)
  218. #define putcrng(iff, crng)  \
  219.     PutCk(iff, ID_CRNG, sizeof(CRange),(BYTE *)crng)
  220. #define putccrt(iff, ccrt)  \
  221.     PutCk(iff, ID_CCRT, sizeof(CcrtChunk),(BYTE *)ccrt)
  222.  
  223. #ifndef NO_PROTOS
  224. /* unpacker.c */
  225. BOOL unpackrow(BYTE **pSource, BYTE **pDest, WORD srcBytes0, WORD dstBytes0);
  226.  
  227. /* packer.c */
  228. LONG packrow(BYTE **pSource, BYTE **pDest, LONG rowSize);
  229.  
  230. /* ilbmr.c  ILBM reader routines */
  231. LONG loadbody(struct IFFHandle *iff, struct BitMap *bitmap,
  232.         BitMapHeader *bmhd);
  233. LONG loadbody2(struct IFFHandle *iff, struct BitMap *bitmap, 
  234.         BYTE *mask, BitMapHeader *bmhd, 
  235.         BYTE *buffer, ULONG bufsize);
  236. LONG loadcmap(struct ILBMInfo *ilbm);
  237. LONG getcolors(struct ILBMInfo *ilbm);
  238. LONG setcolors(struct ILBMInfo *ilbm, struct ViewPort *vp);
  239. void freecolors(struct ILBMInfo *ilbm);
  240. LONG alloccolortable(struct ILBMInfo *ilbm);
  241. ULONG getcamg(struct ILBMInfo *ilbm);
  242.  
  243. /* ilbmw.c  ILBM writer routines */
  244. long initbmhd(BitMapHeader *bmhd, struct BitMap *bitmap,
  245.               WORD masking, WORD compression, WORD transparentColor,
  246.               WORD width, WORD height, WORD pageWidth, WORD pageHeight,
  247.               ULONG modeid);
  248. long putcmap(struct IFFHandle *iff,APTR colortable,UWORD ncolors,UWORD bitspergun);
  249. long putbody(struct IFFHandle *iff, struct BitMap *bitmap,
  250.         BYTE *mask, BitMapHeader *bmHdr,
  251.         BYTE *buffer, LONG bufsize);
  252.  
  253. /* getdisplay.c (used to load a display) */
  254. LONG showilbm(struct ILBMInfo *ilbm, UBYTE *filename);
  255. BOOL unshowilbm(struct ILBMInfo *ilbm);
  256. LONG createdisplay(struct ILBMInfo *);
  257. BOOL deletedisplay(struct ILBMInfo *);
  258. LONG getdisplay(struct ILBMInfo *);
  259. BOOL freedisplay(struct ILBMInfo *);
  260.  
  261. /* getbitmap.c (used if just loading brush or bitmap) */
  262. LONG createbrush(struct ILBMInfo *);
  263. void deletebrush(struct ILBMInfo *);
  264. LONG getbitmap(struct ILBMInfo *);
  265. void freebitmap(struct ILBMInfo *);
  266.  
  267. /* screen.c (opens 1.3 or 2.0 screen) */
  268. struct Screen *openidscreen(struct ILBMInfo *,SHORT,SHORT,SHORT,ULONG);
  269. struct Window *opendisplay(struct ILBMInfo *,SHORT,SHORT,SHORT,ULONG);
  270. ULONG  modefallback(ULONG, SHORT, SHORT, SHORT);
  271. void clipit(SHORT wide, SHORT high, struct Rectangle *spos,
  272.     struct Rectangle *dclip, struct Rectangle *txto,
  273.     struct Rectangle *stdo,struct Rectangle *maxo,
  274.     struct Rectangle * uclip);
  275. BOOL closedisplay(struct ILBMInfo *ilbm);
  276.  
  277. /* loadilbm.c */
  278. LONG loadbrush(struct ILBMInfo *ilbm, UBYTE *filename);
  279. void unloadbrush(struct ILBMInfo *ilbm);
  280.  
  281. LONG queryilbm(struct ILBMInfo *ilbm, UBYTE *filename);
  282.  
  283. LONG loadilbm(struct ILBMInfo *ilbm, UBYTE *filename);
  284. void unloadilbm(struct ILBMInfo *ilbm);
  285.  
  286. /* saveilbm.c */
  287. LONG screensave(struct ILBMInfo *ilbm,
  288.             struct Screen *scr,
  289.             struct Chunk *chunklist1, struct Chunk *chunklist2,
  290.             UBYTE *filename);
  291.  
  292. LONG saveilbm(struct ILBMInfo *ilbm,
  293.         struct BitMap *bitmap, ULONG modeid,
  294.         WORD width, WORD height, WORD pagewidth, WORD pageheight,
  295.         APTR colortable, UWORD count, UWORD bitspergun,
  296.                 WORD masking, WORD transparentColor,
  297.         struct Chunk *chunklist1, struct Chunk *chunklist2,
  298.         UBYTE *filename);
  299.  
  300.  
  301. /* screendump.c (print screen or brush) */
  302. int screendump(struct Screen *scr,
  303.      UWORD srcx, UWORD srcy, UWORD srcw, UWORD srch,
  304.      LONG destcols, UWORD special);
  305.  
  306. /* bmprintc.c (write C source for ILBM) */
  307. void BMPrintCRep(struct BitMap *bm, FILE *fp, UBYTE *name, UBYTE *fmt);  
  308.  
  309. #endif /* NO_PROTOS */
  310.  
  311. #endif /* IFFP_ILBM_H */
  312.