                           PICTURE FILE FORMATS
                         by Bob Montgomery 9-21-90

Dr. Halo CUT files

The DR. Halo CUT file header has the following content:
        struct Halocut
        {    int  width;
             int  height;
             int  dummy;
        } ;
The Dr. Halo CUT file picture data is run length encoded for each picture
row as follows:
    1. Get a code byte from the data stream.
       If the code byte is 0, then this is the end of this row.
       The 'count' is the 7 lsb's of the code byte, and can vary from 1 to 127.
       The code byte msb determines if there is repeated data as follows:
            a. msb = 1, get the next byte and repeat it 'count' times.
            b. msb = 0, get the next 'count' bytes.

The Dr. Halo Palette (PAL) file header has the following content (40 bytes):
        struct Hpal
        {    BYTE ID[2];                                 Should be AH
             int  version, size;
             char filetype, subtype;
             WORD brdid, grmode;
             int  maxindex, maxred, maxgreen, maxblue;   Colors = maxindex + 1
             char signature[8], filler[12];              "Dr. Halo", 12 0's
        } ;
The palette data is integer triples (R, G, B) for each color in the palette.
The palette file data (including the header) is in 512 byte blocks. If there
     is not a full integer triple at the end of a block, the data should be
     ignored and the next block started.

Deluxe Paint II LBM & IFF files

The Deluxe Paint LBM (and IFF) file header (40 bytes) has the following
content:
     struct dp2
     {   char msg1[4];               "FORM"
         BYTE a3, a2, a1, a0;        File length - 8  (read left to right)
         char msg2[8];               "ILBMBMHD"
         BYTE b3, b2, b1, b0;        Length of header (read left to right)
         int  width, length, xoff, yoff;
         BYTE planes, masking, compression, pad;
         int  tansparent;
         BYTE x_aspect, y_aspect;
         int  screenwidth, screenheight;
     } ;
   There may be a color map following a string "CMAP" in the file. After CMAP
        is the length of the color map (4 bytes, read left to right). The color
        map is byte triples (R, G, B) for each colors. The number of colors is
        1 shifted left by planes (1 << planes).
   The actual picture data follows a string "BODY" and length of the picture
        data (4 bytes read left to right). The picture data is organized on a
        color plane basis for DP2, and on a pixel basis for DP2e (enhanced).
        Thus, for DP2:
            There are (width / 8) bytes per row.
            The data stream for each row consists of all the bytes for plane 0,
                followed by all the bytes for plane 1, etc.
        and for DP2e:
            There are (width) bytes/row, where each byte is a pixel color.
   If the data is uncomperessed (compression flag = 0), the data stream bytes
        are fed to the output unmodified. If it is compressed, it is run length
        encoded as follows:
            Get a code byte from the data stream.
            If the msb is 1, the 'count' is (1 - code), max = 127. Get the next
                byte from the data stream, and repeat it 'count' times.
            If the msb is 0, the 'count' is (1 + code), max = 128. Get the next
                'count' bytes from the data stream.

MacIntosh MAC files

The MAC file header (128 bytes) has the following content:
If bytes 0, 74, and 82 are 0, and byte 1 is less than 64 the picture data
     starts at byte 640; other wise it starts at byte 512.
The picture is always 576 wide x 720 long, and 2 colors (black & white).
The data has 8 pixels/byte, so there are 576/8 = 72 bytes/row.
The picture data is run length encoded as follows:
    Get a code byte from the data stream.
    If the msb is 1, the 'count' is (1 - code), max = 127. Get the next
        byte from the data stream, and repeat it 'count' times.
    If the msb is 0, the 'count' is (1 + code), max = 128. Get the next
        'count' bytes from the data stream.

Pictor/ PC Paint files

The Pictor/PC Paint header (17 bytes) has the following content:
     struct PCPheader
     {    int  ID;       ID for Pictor/PC Paint files, should be 0x1234
          int  Hor;      Horizontal size
          int  Vert;     Vertical size
          int  Xoff;     X offset into pic
          int  Yoff;     Y offset into pic
          BYTE Bpp;      Lo nib=bits/pixel, Hi nib=additional planes
          BYTE Ident;    Should be 0FFh for PC Paint 2.0+
          BYTE Vmode;    Video mode for pic, G=EGA, L=VGA, M=640x480x16, etc.
          int  Descr;    Descriptor for pic, 0=>B&W, 3=>EGA, (>=4)=>VGA
          int  Bcount;   Number of bytes of info to follow, should be 0 if
                         B&W, 16 if EGA, and (3 * colors) for VGA.
     } ;
The number of colors is determined by the Bpp byte. The palette info follows
     and is Bcount bytes long. Then comes a 'block count' integer, which is
     the number of blocks of picture info to follow. PC Paint only did EGA,
     and the data was at 2 pixels/byte. Pictor EGA is on a plane basis (B, G,
     R, I) where all the data for plane 0 is followed by all the data for
     plane1, etc. Pictor B&W is at 8 pixels/byte. Pictor VGA is at 1
     byte/pixel on a color basis.
The picture data is broken into blocks of bytes with the following 5 byte
header:
     struct PCP_BLOCK_HDR
     {    WORD packed;     Packed bytes this block, including header.
          WORD unpacked;   Unpacked bytes the block expands to.
          BYTE runmarker;  Byte which denotes a run of same data.
     } ;
The data is encoded inside a block into single bytes and runs as follows:
1. Get a byte from the data stream.
2. If the byte is not the runmarker, it is the data.
3. If the byte is the runmarker, the next byte is the run count (255 max). If
   the run count is 0, the next word (2 bytes) is the run count (65535 max).
   The next byte is the data to repeat for the run count.

EGA Paint & ColoRIX file

The EGA Paint and ColoRIX files have the following headers:
     1. EGA Paint files have a 16 byte EGA palette.
     2. ColoRIX files have the following info:
         struct RIXHDR
         {   char id[4];             Should be RIX3
             int  xres, yres;
             int  mode;              Ignored
         } ;
EGA Paint files have extensions SCR (640x350; 112016 bytes long), and
     SCP (640x480; 153616 bytes long). The data is uncompressed and on a
     plane basis. The planes are ordered B, R, G, I.
ColoRIX files are on a plane basis for EGA (B, G, R, I) and on a pixel color
     basis for VGA. They have extensions:
         SCI (320x200)
         SCR (640x350)
         SCP (640x480)
         SCG (800x600)
         SCU (1024x768)

Targa Files

Targa files have a header as follows
     struct TGA {
         BYTE idlen;       /* number of bytes in Ident Field */
         BYTE colmptype;   /* color map type (0 for none) */
         BYTE imagetype;   /* image type (2 is unmapped RGB) */
         WORD cmorg;       /* color map origin */
         WORD cmlen;       /* color map length in # of colors */
         BYTE cmbits;      /* number of bits per color map entry */
         WORD xoff;
         WORD yoff;
         WORD xsize;
         WORD ysize;
         BYTE bpix;       /* number of bits per pixel in pict */
         BYTE imagedesc;  /* 0 for TGA and TARGA images */
     } ;
If the 2 lsb's of imagetype are 1, the data is for a greyscale image.
For imagetype of 7 or less the file has uncompressed picture data. For
imagetype of 8 or more it is RLE compressed as follows:
     1. Get the code byte. The 'count' is {(code & 127) + 1} (1 thru 128).
     2. If the msb = 0, output the next 'count' colors.
     3. If the msb = 1, output the next color 'count' times.
Targa 8 is usually gray scale. For Targa 16 there are 2 bytes/color; 5 lsb's are
blue, next 5 bits are green, next 5 bits are red. For Targa 24, there are 3
bytes/color; 1st is blue, next is green, last is red. For Targa 32, there are 4
bytes/color; 1st is blue, next is green, next is red, and last throw away.

ZSoft PCX files

ZSoft PCX files have the following 68 byte header:
     struct Zsheader
     {    BYTE Mfg;           /* ID for ZSoft files, 0A hex */
          BYTE Ver;           /* Version, 5 */
          BYTE Encode;        /* Encoded pic data if 1 */
          BYTE Bpp;           /* Bits/pixel */
          int  X1;            /* Left col */
          int  Y1;            /* Top row */
          int  X2;            /* Right col */
          int  Y2;            /* Bottom row */
          int  Xres;          /* Horiz size of screen */
          int  Yres;          /* Vert size of screen */
          BYTE zpal[48];      /* 3 bytes/palette reg */
          BYTE Vmode;         /* Video mode, ignored */
          BYTE Planes;        /* # color planes in pic */
          int  Bpl;           /* Bytes/line in pic */
     } ;
This is followed by 60 bytes of filler (0's), and then the picture data.
The number of colors is 1 << (Bpp * Planes).
If Ver = 5, go to the 769th byte from the end of the file. if this is 12, the
     next 768 bytes are byte triples (R, G, B) of palette data.
ZSoft files for VGA are 1 byte/pixel, and for EGA are on a plane basis
     (B, G, R, I) for each row.
ZSoft files are encoded as follows:
 1. Read a code byte. The 'count' is the 6 lsb's (63 max).
 2. If the 2 msb's of code = 1, the 'count' is the 6 lsb's (63 max).
    Then read a data byte and repeat it 'count' times to the output.
 3. If the 2 msb's of code = 0, the code byte is written directly to the output.
 4. If an output data byte of C0 - FF is required, it is written as 'C1h,data'
    where the C1h indicates a count of 1.
