204 lines
9.8 KiB
Plaintext
204 lines
9.8 KiB
Plaintext
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.
|