home *** CD-ROM | disk | FTP | other *** search
/ Avalon - 3D Objects & Resources / Avalon.iso / frmtspcs / techref.txt < prev    next >
Text File  |  1995-01-01  |  21KB  |  617 lines
  1. Technical Reference Manual
  2.  
  3. Including Information For:
  4. Publisher's Paintbrush
  5. PC Paintbrush Plus
  6. PC Paintbrush
  7. FRIEZE Graphics
  8.  
  9.  
  10.  
  11.  
  12.  
  13.  
  14.  
  15.  
  16.  
  17. ZSoft Corporation
  18. 450 Franklin Rd. Suite 100
  19. Marietta, GA  30067
  20. (404) 428-0008
  21.  
  22.  
  23.  
  24.  
  25. Copyright 1988 ZSoft Corporation
  26. Table of Contents
  27. Introduction                  3
  28. Image File (.PCX) Format        4
  29. Decoding the .PCX File Format        6
  30. Palette Information Description        7
  31. PC Paintbrush Bitmap Font Format    9
  32. Sample "C" Routines                10
  33. FRIEZE Technical Information        13
  34. Pre-7.00 FRIEZE Specifications        14
  35. Pre-7.00 FRIEZE Function Calls        15
  36. Pre-7.00 FRIEZE Error Codes        16
  37. 7.00 and later FRIEZE Specifications    17
  38. 7.00 and later FRIEZE Function Calls    18
  39. 7.00 and later FRIEZE Error Codes    19
  40. The .PCX Programmer's Toolkit        21
  41.  
  42.  
  43.  
  44.  
  45. Introduction
  46. This booklet was designed to aid developers and users in
  47. understanding the technical aspects of the .PCX file format and
  48. the use of FRIEZE.
  49. Any comments, questions or suggestions about this booklet should
  50. be sent to:
  51. ZSoft Corporation
  52. Technical Support Department
  53. ATTN: Technical Reference Manual
  54. 450 Franklin Rd. Suite 100
  55. Marietta, GA  30067
  56.  
  57.  
  58.  
  59.  
  60. IMAGE FILE (.PCX) FORMAT
  61. The information in this section will be useful if you want to
  62. write a program to read or write PCX files (images).  If you want
  63. to write a special case program for one particular image format
  64. you should be able to produce something that runs twice as fast
  65. as "Load from..." in PC Paintbrush.
  66. Image files used by PC Paintbrush product family and FRIEZE
  67. (those with a .PCX extension) begin with a 128 byte header. 
  68. Usually you can ignore this header, since your images will all
  69. have the same resolution.  If you want to process different
  70. resolutions or colors, you will need to interpret the header
  71. correctly.  The remainder of the image file consists of encoded
  72. graphic data.  The encoding method is a simple byte oriented
  73. run-length technique.  We reserve the right to change this method
  74. to improve space efficiency.  When more than one color plane is
  75. stored in the file, each line of the image is stored by color
  76. plane (generally ordered red, green, blue, intensity), As shown
  77. below.
  78. Scan line 0:     RRR...
  79.         GGG...
  80.         BBB...
  81.         III...
  82. Scan line 1:     RRR...
  83.         GGG...
  84.         BBB...
  85.         III...
  86. (etc.)
  87. The encoding method is:
  88. FOR  each  byte,  X,  read from the file
  89.     IF the top two bits of X are  1's then
  90.         count = 6 lowest bits of X
  91.         data = next byte following X
  92.     ELSE
  93.         count = 1
  94.         data = X
  95. Since the overhead this technique requires is, on average,  25%
  96. of the non-repeating data and is at least offset whenever  bytes
  97. are repeated, the file storage savings are usually considerable.
  98. The format of the file header is shown below.
  99.  
  100. ZSoft .PCX FILE HEADER FORMAT
  101.  
  102. Byte    Item            Size    Description/Comments
  103.  
  104. 0    Manufacturer    1    Constant Flag  10 = ZSoft .PCX
  105. 1    Version     1    Version information:
  106.                 0 = Version 2.5
  107.                 2 = Version 2.8 w/palette information
  108.                 3 = Version 2.8 w/o palette information
  109.                 5 = Version 3.0
  110. 2    Encoding    1    1 = .PCX run length encoding
  111. 3    Bits per pixel    1    Number of bits/pixel per plane
  112. 4    Window      8    Picture Dimensions 
  113.                 (Xmin, Ymin) - (Xmax - Ymax)
  114.                 in pixels, inclusive
  115. 12    HRes        2    Horizontal Resolution of creating device
  116. 14    VRes        2    Vertical Resolution of creating device
  117. 16    Colormap    48    Color palette setting, see text
  118. 64    Reserved    1
  119. 65    NPlanes            1    Number of color planes
  120. 66    Bytes per Line    2    Number of bytes per scan line per 
  121.                 color plane (always even for .PCX files)
  122. 68    Palette Info    2    How to interpret palette - 1 = color/BW,
  123.                 2 = grayscale
  124. 70    Filler      58    blank to fill out 128 byte header
  125.  
  126. NOTES:
  127. All sizes are measured in BYTES.
  128. All variables of size 2 are integers.
  129.  
  130.  
  131.  
  132. Decoding .PCX Files
  133. First, find the pixel dimensions of the image by calculating
  134. [XSIZE = Xmax - Xmin + 1] and [YSIZE = Ymax - Ymin + 1].  Then
  135. calculate how many bytes are required to hold one complete
  136. uncompressed scan line:
  137. TotalBytes = NPlanes * BytesPerLine
  138. Note that since there are always an integral number of bytes,
  139. there will probably be unused data at the end of each scan line. 
  140. TotalBytes shows how much storage must be available to decode
  141. each scan line, including any blank area on the right side of the
  142. image.  You can now begin decoding the first scan line - read the
  143. first byte of data from the file.  If the top two bits are set,
  144. the remaining six bits in the byte show how many times to
  145. duplicate the next byte in the file.  If the top two bits are not
  146. set, the first byte is the data itself, with a count of one.
  147. Continue decoding the rest of the line.  Keep a running subtotal
  148. of how many bytes are moved and duplicated into the output
  149. buffer.  When the subtotal equals TotalBytes, the scan line is
  150. complete.  There will always be a decoding break at the end of
  151. each scan line.  But there will not be a decoding break at the
  152. end of each plane within each scan line.  When the scan line is
  153. completed, there may be extra blank data at the end of each plane
  154. within the scan line.  Use the XSIZE and YSIZE values to find
  155. where the valid image data is.  If the data is multi-plane
  156. BytesPerLine shows where each plane ends within the scan line.
  157. Continue decoding the remainder of the scan lines.  There may be
  158. extra scan lines at the bottom of the image, to round to 8 or 16
  159. scan lines.
  160. Palette Information Description
  161. EGA/VGA 16 Color Palette Information
  162. The palette information is stored in one of two different
  163. formats.  In standard RGB format (IBM EGA, IBM VGA) the data is
  164. stored as 16 triples.  Each triple is a 3 byte quantity of Red,
  165. Green, Blue values.  The values can range from 0-255 so some
  166. interpretation into the base card format is necessary.  On an IBM
  167. EGA, for example, there are 4 possible levels of RGB for each
  168. color.  Since 256/4 = 64, the following is a list of the settings
  169. and levels:
  170. Setting        Level
  171. 0-63        0
  172. 64-127        1
  173. 128-192        2
  174. 193-254        3
  175.  
  176. VGA 256 Color Palette Information
  177. ZSoft has recently added the capability to store palettes
  178. containing more than 16 colors in the .PCX image file.  The 256
  179. color palette is formatted and treated the same as the 16 color
  180. palette, except that it is substantially longer.  The palette
  181. (number of colors x 3 bytes in length) is appended to the end of
  182. the .PCX file, and is preceded by a 12 decimal.  To determine the
  183. VGA BIOS palette you need only divide the values read in the
  184. palette by 4.
  185. To access a 256 color palette:
  186. First, check the version number in the header, if it contains a 5
  187. there is a palette.
  188. Second, read to the end of the file and count back 769 bytes. 
  189. The value you find should be a 12 decimal, showing the presence
  190. of a 256 color palette.
  191. CGA Color Palette Information
  192. For a standard IBM CGA board, the palette settings are a bit more
  193. complex.  Only the first byte of the triple is used.  The first
  194. triple has a valid first byte which represents the background
  195. color.  To find the background, take the (unsigned) byte value
  196. and divide by 16.  This will give a result between 0-15, hence
  197. the background color.  The second triple has a valid first byte,
  198. which represents the foreground palette.  PC Paintbrush supports
  199. 8 possible CGA palettes, so when the foreground setting is
  200. encoded between 0 and 255, there are 8 ranges of numbers and the
  201. divisor is 32.
  202.  
  203. CGA Color Map
  204. Header Byte #16 
  205. Background color is determined in the upper four bits.
  206. Header Byte #19
  207. Only upper 3 bits are used, lower 5 bits are ignored.  The first
  208. three bits that are used are ordered C, P, I.  These bits are
  209. interpreted as follows:
  210. c: color burst enable - 0 = color; 1 = monochrome
  211. p: palette - 0 = yellow; 1 = white
  212. i: intensity - 0 = dim; 1 = bright
  213.  
  214. PC Paintbrush Bitmap Character Format
  215. The bitmap character fonts are stored in a particularly simple
  216. format.  The format of these characters is as follows:
  217. Header (2 bytes)
  218. font width    db    0a0h + character width (in dots)
  219. font height    db    character height (in dots)
  220. Character Widths (256 bytes)
  221. char widths    db    256 dup(each char's width +1)
  222. Character Images
  223. (remainder of the file)
  224. The characters are stored in ASCII order and as many as 256 may
  225. be provided.  Each character is left justified in the character
  226. block, all characters take up the same number of bytes.
  227. Bytes are organized as N strings, where each string is one scan
  228. line of the character.  See figure 2.
  229. For example, each character in a 5x7 font requires 7 bytes.  A
  230. 9x14 font uses 28 bytes per character (stored two bytes per scan
  231. line in 14 sets of 2 byte packets).  Custom fonts may be any size
  232. up to the current maximum of 10K bytes allowed for a font file.
  233.  
  234. Sample "C" Routines
  235. The following is a simple set of C subroutines to read data from
  236. a .PCX file.
  237. /* This procedure reads one encoded block from the image file and
  238. stores a count and data byte. Result:
  239. 0 = valid data stored
  240. EOF = out of data in file */
  241. encget(pbyt, pcnt, fid)
  242. int *pbyt;     /* where to place data */
  243. int *pcnt;     /* where to place count */
  244. FILE *fid;     /* image file handle */
  245. {
  246. int i;
  247.     *pcnt = 1;     /* safety play */
  248.     if(EOF    ==    (i    =    getc(fid))) return(EOF);
  249.     if(0xc0 == (0xc0 & i))   {
  250.      *pcnt = 0x3f&i;
  251.     if(EOF == (i=getc(fid)))
  252.             return(EOF);
  253. }
  254. *pbyt = i;
  255. return(0);
  256. }
  257. /* Here's a program fragment using encget.   This reads an entire
  258. file and stores it in a (large) buffer, pointed to by the
  259. variable "bufr". "fp" is the file pointer for the image */
  260. while (EOF != encget(&chr, &cnt, fp))
  261.         for (i = 0; i             *bufr++ = chr;
  262. The following is a set of C subroutines to write data to a .PCX
  263. file.
  264.  /* This subroutine encodes one scanline and writes it to a file
  265. */
  266. encLine(inBuff, inLen, fp)
  267. unsigned char *inBuff;  /* pointer to scanline data */
  268. int inLen;            /* length of raw scanline in bytes */
  269. FILE *fp;            /* file to be written to */
  270. {  /* returns number of bytes written into outBuff, 0 if failed
  271. */
  272.     unsigned char this, last;
  273. int srcIndex, i;
  274. register int total;
  275. register unsigned char runCount; /* max single runlength is 63 */
  276. total = 0;
  277. last = *(inBuff);        runCount = 1;
  278.  
  279. for (srcIndex = 1; srcIndex  inLen; srcIndex++) {
  280.     this = *(++inBuff);
  281.     if (this == last)    {
  282.          runCount++;    /* it encodes */
  283.         if (runCount == 63)    {
  284.             if (!(i=encput(last, runCount, fp)))
  285.                 return(0);
  286.             total += i;
  287.             runCount = 0;
  288.             }
  289.         }
  290.     else    {   /* this != last */
  291.         if (runCount)    {
  292.             if (!(i=encput(last, runCount, fp)))
  293.                 return(0);
  294.             total += i;
  295.             }
  296.         last = this;
  297.         runCount = 1;
  298.         }
  299.     }    /* endloop */
  300. if (runCount)    {        /* finish up */
  301.     if (!(i=encput(last, runCount, fp)))
  302.         return(0);
  303.     return(total + i);
  304.     }
  305. return(total);
  306. }
  307.  
  308. /* subroutine for writing an encoded byte pair 
  309. (or single byte  if it doesn't encode) to a file */
  310. encput(byt, cnt, fid) /* returns count of bytes written, 0 if err
  311. */
  312. unsigned char byt, cnt;
  313. FILE *fid;
  314. {
  315. if(cnt) {
  316.     if( (cnt==1) && (0xc0 != (0xc0&byt)) )    {
  317.         if(EOF == putc((int)byt, fid))
  318.             return(0); /* disk write error (probably full) */
  319.         return(1);
  320.         }
  321.     else        {
  322.         if(EOF == putc((int)0xC0 | cnt, fid))
  323.             return(0);     /* disk write error */
  324.         if(EOF == putc((int)byt, fid))
  325.             return(0);     /* disk write error */
  326.         return(2);
  327.         }
  328.     }
  329. return(0);
  330. }
  331.  
  332.  
  333.  
  334.  
  335. FRIEZE Technical Information
  336.  
  337.  
  338. FRIEZE Information
  339.  
  340. FRIEZE is a memory resident utility that allows you to capture
  341. and save graphic images from other programs.  You can then bring
  342. these images into PC Paintbrush for editing and enhancement.
  343. FRIEZE was rewritten for use in PC Paintbrush Plus, and so the
  344. technical information about FRIEZE has changed dramatically.   To
  345. easily provide technical information for all versions of FRIEZE,
  346. we have split this section of the manual into two parts, one
  347. about PRE-7.00 versions of FRIEZE, and one about the current
  348. versions (7.00 or higher).
  349. FRIEZE 7.10 and later can be removed from memory (this can return
  350. you almost 85K of DOS RAM, depending on your configuration).  To
  351. do this, you can choose to release FRIEZE from memory in the
  352. PCINSTAL menu, or at any time by changing directories to your PC
  353. PAINTBRUSH product directory and typing the word "FRIEZE."
  354.  
  355.  
  356. Pre-7.00 FRIEZE Specifications
  357.  
  358.  
  359. FRIEZE Print Option Settings
  360.  
  361. FRIEZE can easily adapt to incomplete printer cables (missing IBM
  362. specified status lines) and will drive either serial or parallel
  363. devices.  Note that FRIEZE always uses the standard BIOS calls,
  364. so a non-handshaking device will time out, but can be told to
  365. ignore such things as paper out.
  366. The FRIEZE command syntax is:
  367. FRIEZE Xnaarr
  368. Where:
  369. X = either Parallel or Serial
  370. n = port number 
  371. aa = a two digit hexadecimal code for which return bits cause an
  372. abort
  373. rr = a two digit hexadecimal code for which return bits cause a
  374. retry
  375. Examples:
  376. FRIEZE P1 - use the default settings of Parallel output, port
  377. number 1, abort mask of 28h, and retry mask of 01h
  378. FRIEZE P2 - use printer port #2
  379. FRIEZE S1 - use serial port #1, and Xon/Xoff handshaking
  380. FRIEZE P10028 - use printer port #1, abort mask of 00 (nothing is
  381. read as an error) and retry mask of 28h
  382. Interpreting the codes:
  383. On return from the parallel printer call, the bit interpretations
  384. are:
  385. 80h - busy signal (0=busy)
  386. 40h - acknowledge
  387. 20h - out of paper
  388. 10h - selected
  389. 08h - I/O error
  390. 04h - unused
  391. 02h - unused
  392. 01h - time out
  393.  
  394.  
  395. FRIEZE Function Calls
  396.  
  397. FRIEZE is operated using software interrupt number  10h (the
  398. video interrupt call).
  399. To make a FRIEZE function call, load 75 (decimal) into the  AH
  400. register, the function call number into the CL register and then,
  401. either load AL with the function argument or load ES and BX with
  402. a segment and offset which point to the function argument then do
  403. an int 10h.
  404. FRIEZE will return a result code number in AX--zero means 
  405. success, other values show error conditions.  All other registers
  406. are unchanged.
  407. No.    Definition     Arguments
  408. 0    Print Window    AL = mode: 0 - character,
  409.                  1 - normal, 2 - sideways
  410. 1    Read Window    ES:BX - string
  411.                 (filename to read from)
  412. 2    Write Window     ES:BX - string
  413.                 (filename to write to)
  414. 3    Print Width    AL = width in 1/4 inches
  415. 4    Print Height    AL = height in 1/4 inches
  416. 5    Reserved
  417. 6    Set Left Margin    AL = printout margin in 
  418.                 1/4 inches
  419. 7    Set Window Size    ES:BX - 4 element word
  420.                 vector of window settings:
  421.                 Xmin, Ymin, Xmax, Ymax
  422. 8    Reserved
  423. 9    Set Patterns    ES:BX - 16 element vector
  424.                 of byte values containing the
  425.                  screen-to-printer color
  426.                 correspondence
  427. 10    Get Patterns    ES:BX - room for 16 bytes as
  428.                 above
  429. 11    Set Mode    AL = mode number
  430.                 (See SETMODE command)
  431. 12    Reserved
  432. 13    Reserved
  433. 14    Reserved
  434. 15    Get Window    ES:BX - room for 4 words of
  435.                  the current window settings
  436. 16     Set Print Options    ES:BX - character string of
  437.                 printer options.  Same format
  438.                 as for the FRIEZE command.
  439. 17    Initialize    ES:BX - 3 word array
  440.                 containing data from 
  441.                 PC Paintbrush Disk 1 file
  442.                 CARDS.DAT (Hres, Vres,
  443.                 optional code number)
  444. All character strings are ended by a zero byte (ASCIIZ format).
  445.  
  446.  
  447. FRIEZE Error Codes
  448.  
  449. When FRIEZE is called using interrupt 10 hex, it will return an
  450. error code in the AX register.  A value of zero shows that there
  451. was no error.  A nonzero result means there was an error.  These
  452. error codes are explained below.
  453. 0    No Error
  454. 1    Printout was stopped by user with the ESC key
  455. 2    Reserved
  456. 3    File read error
  457. 4    File write error or printer error
  458. 5    File not found
  459. 6    Invalid Header or can't create file
  460.     (not a picture or wrong screen mode)
  461. 7    File close error
  462. 8    Disk error - usually drive door open
  463. 9    Not used
  464. 10    Invalid command - CL was set to call a nonexistent 
  465.     FRIEZE function
  466. 11    Not used
  467. 12    Not used
  468.  
  469.  
  470. 7.00 and Later FRIEZE
  471.  
  472. The newer versions of FRIEZE have a different number of
  473. parameters on its command line.  The new FRIEZE command line
  474. format is:
  475. FRIEZE {PD} {Xnaarr} {flags} {video} {hres} {vres} {vnum}
  476. Where:
  477. {PD}    Printer driver filename (without the .PDV extension)
  478. {Xnaarr}
  479.         X=S for Serial Printer X=P for Parallel Printer
  480.         n = port number
  481.         aa = Two digit hex code for which return bits cause
  482.              an abort
  483.         rr = Two digit hex code for which return bits cause
  484.             a retry
  485. {flags}    Four digit hex code
  486.             First Digit controls Length Flag
  487.             Second Digit controls Width Flag
  488.             Third Digit controls Mode Flag
  489.             Fourth Digit controls BIOS Flag
  490. NOTE:    The length, width and mode flags are printer driver
  491. specific.
  492.         See PRINTERS.DAT on disk 1 for correct use.  In 
  493.         general width flag of 1 means wide carriage, and 
  494.         0 means standard width.  Length flag of 0 and 
  495.         mode flag of 0 means use standard printer driver 
  496.         settings.
  497. {video} Video driver combination, where the leading digit
  498.         signifies the high level video driver and the rest
  499.         signifies the low level video driver
  500.         Example = 1EGA - uses DRIVE1 and EGA.DEV
  501. {hres}    Horizontal resolution of the desired graphics mode
  502. {vres}    Vertical resolution of the desired graphics mode
  503. {vnum}    Hardware specific parameter (usually number of color
  504. planes)
  505. Note: The last four parameters can be obtained from the CARDS.DAT
  506. file, on Disk 1 of your PC Paintbrush diskettes.
  507. Parallel printer return codes:
  508.     80h - Busy Signal (0=busy)
  509.     40h - Acknowledge
  510.     20h - Out of paper
  511.     10h - Selected
  512.     08h - I/O error
  513.     04h - Unused
  514.     02h - Unused
  515.     01h - Time out
  516.  
  517.  
  518. FRIEZE Function Calls
  519.  
  520. FRIEZE is operated using software interrupt number  10h (the
  521. video interrupt call).
  522. To make a FRIEZE function call, load 75 (decimal) into the  AH
  523. register, the function number into the CL register and then,
  524. either load AL with the function argument or load ES and BX with
  525. a segment and offset which point to the function argument then do
  526. an int 10h.
  527. FRIEZE will return a result code number in AX--zero means 
  528. success, other values show error conditions.  All other registers
  529. are unchanged.
  530. No.    Definition     Arguments
  531. 0    Reserved
  532. 1    Load Window    ES:BX - string
  533.                 (filename to read from)
  534. 2    Save Window     ES:BX - string
  535.                 (filename to write to)
  536. 3    Reserved
  537. 4    Reserved    
  538. 6    Reserved    
  539. 7    Set Window Size    ES:BX - 4 element word
  540.                  vector of window settings:
  541.                 Xmin, Ymin, Xmax, Ymax
  542. 8    Reserved
  543. 9    Set Patterns    ES:BX - 16 element vector
  544.                 of byte values containing the
  545.                 screen-to-printer color
  546.                 correspondence
  547. 10    Get Patterns    ES:BX - room for 16 bytes as
  548.                 above
  549. 11    Set Mode    AL = mode number
  550.                 (See SETMODE command)
  551. 12    Reserved
  552. 13    Reserved
  553. 14    Reserved
  554. 15    Get Window    ES:BX - room for 4 words of
  555.                 the current window settings
  556. 16     Set Print Options    ES:BX - character string of
  557.                  printer options.  Same format
  558.                 as for the FRIEZE command.
  559. 17    Reserved
  560. 18    Reserved
  561. 19    Reserved
  562. 20    Get FRIEZE Version.    AH gets the whole number portion 
  563.                    and AL gets the decimal portion of
  564.                     the version number.  If AH=0, it
  565.                  can be assumed that it is a 
  566.                   pre-7.00 version of FRIEZE.
  567. 21    Set Parameters    ES:BX points to an 8 word table 
  568.                 (16 bytes) of parameter settings: 
  569.                  TopMargin, LeftMargin, HSize,VSize,
  570.                  Quality/Draft Mode, PrintHres, 
  571.                 PrintVres, Reserved.    
  572.                  Margins and sizes are specified in 
  573.                 hundredths of inches.
  574.                  Q/D mode parameter values:
  575.                 0 - draft print mode
  576.                 1 - quality print mode
  577.                  2 - use Hres, Vres for output 
  578.                  resolution.  Print resolutions are 
  579.                 specified in DPI.  Any parameter
  580.                   which should be left unchanged may    
  581.                 be filled with a (-1) (0FFFF hex).  
  582.                   The reserved setting should be filled
  583.                 with a (-1).
  584. 22    Get Parameters    ES:BX points to an 8 word table 
  585.                 (16 bytes) where parameter settings
  586.                 are held.
  587. 23    Get Printer Res    ES:BX points to a 12 word table
  588.                  (24 bytes) where printer resolution
  589.                  pairs (6 pairs) are held.
  590. NOTE: All character strings are ended by a zero byte 
  591.     (ASCIIZ format).
  592.  
  593.  
  594. FRIEZE Error Codes
  595.  
  596. When FRIEZE is called using interrupt 10 hex, it will return an
  597. error code in the AX register.  A value of zero shows that there
  598. was no error.  A nonzero result means there was an error.  These
  599. error codes are explained below.
  600. 0    No Error
  601. 1    Printout was stopped by user with the ESC key
  602. 2    Reserved
  603. 3    File read error
  604. 4    File write error
  605. 5    File not found
  606. 6    Invalid Header - not an image, wrong screen mode
  607. 7    File close error
  608. 8    Disk error - usually drive door open
  609. 9    Printer error - printer is off or out of paper
  610. 10    Invalid command - CL was set to call a nonexistent 
  611.     FRIEZE function
  612. 11    Can't create file - write protect tab or disk is full
  613. 12    Wrong video mode - FRIEZE cannot capture text screens.
  614.  
  615.  
  616.  
  617.