
EGI
---------------------------------------------------------------------------
                                                                Version 2.2
                                                                  July 1998


Thank you for your interest in EGI. The EGI tools are used to create
and play Autodesk Animator FLIC files. These animations can be embedded in
your programs. See EGI.DOC for a complete description of both the FLIC
compiler and the FLIC player in the EGI product.

This is an evaluation version. The evaluation version may be distributed in
its entirity. Commercial information is at the bottom of this file.

    ITB CompuPhase
    Brinklaan 74-b
    1404 GL  Bussum
    The Netherlands (Pays Bas)

    Fax:        +31 35 693 9293
    Compuserve: 100115,2074
    e-mail:     CompuPhase@compuserve.com
    WWW:        http://ourworld.compuserve.com/homepages/CompuPhase




PRODUCT OVERVIEW
----------------

EGI is a tool to create and play back frame based animation sequences.
These sequences can be embedded into a (multimedia) application that runs
under Microsoft Windows 3.x or Microsoft Windows 95. The product consists
of a compiler, players for the supported environments and a decompiler
(see Product Components).

The compiler takes a series of pictures as input (in the BMP, PCX or SPR
formats) plus a script file that relates the pictures to each other. The
output consists of a single file with the animation sequences (there can
be multiple sequences per generated output file). The format of the output
file is a superset of the FLIC format that is used by Autodesk Animator
and related products. If desired, the EGI compiler can create FLIC files
that are fully compatible with Autodesk Animator.

The EGI players are dynamically loaded libraries (DLLs) that take a
compiled animation file as input and display the frames at the screen
location and the speed as specified by an application. Both files created
by Autodesk Animator (or related products) and files created by EGI are
accepted. There are separate players for 16-bit and 32-bit Microsoft
Windows environments. The players offer a rich API by means of which they
are easily integrated with C or other programming languages.

The decompiler is provided to aid converting existing FLIC files to the
enhanced format that is used by EGI. Through this enhanced format,
features like segmentation and transparency are achieved.



New in version 2.2
------------------
Version 2.2 adds minor features, such as support for FLIC files embedded
in Windows Help files and improved support for Windows NT.

o  The window of ECOMPW, the Windows version of the EGI compiler, can now
   be resized and be maximized. The integrated editor can thus be nearly
   full screen.

o  The 32-bit player DLL supports Unicode filenames. Currently, this only
   works under Windows NT (Windows 95 has only very limited support for
   Unicode). To open a file with an Unicode filename, call FlicOpenEx()
   and add the FLIC_FLAG_UNICODE flag in the "wFlags" parameter. The filename
   and password string can then be passed as Unicode strings (though you
   need to cast them to "LPSTR" type).

o  Another new flag, FLIC_FLAG_FILEHANDLE, tells FlicOpenEx() that the
   "szFilename" parameter is in fact a file handle of an already opened
   file. FlicOpenEx() starts reading the file from the current position
   in the file.

o  The players can now function as extension DLLs for the Microsoft WinHelp
   viewers. In a help file, you can define "embedded windows" with content
   that is defined by an external DLL (in the case of EGI, the embedded window
   displays a FLIC animation). The FLIC file itself is compiled with the
   help file.

o  A 32-bit MCI driver is now included. The filename is MCIEGI32.DLL (in
   accordance with the Windows NT naming conventions, the extension is
   DLL, not DRV). 32-bit programs running on Windows NT require a 32-bit MCI
   driver; 16-bit programs running on Windows NT need a 16-bit MCI driver.

   The path to the MCI driver must be added the registry under Windows NT
   (in Windows 3.x and Windows 95, the MCI drivers are listed in the
   SYSTEM.INI file). The 16-bit driver and the 32-bit driver should be
   mentioned under the keys:

   [HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows NT\CurrentVersion\MCI Extensions]
   flc=Animation

   [HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows NT\CurrentVersion\MCI]
   Animation=mciegi.drv

   [HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows NT\CurrentVersion\MCI32]
   Animation=mciegi32.dll

o  In the 32-bit DLL, a call to FlicOpenEx() that failed (e.g., because the
   requested file does not exist) did not release a mutex semaphore handle
   that it had allocated. This is now corrected.
   The same problem (and fix) also applies to FlicOpen().
   This problem does not apply to the 16-bit DLL.

o  The extended MCI commands (copied from the MCI driver for Video for
   Windows) like "setaudio" and "setvideo" aborted with an error code. This
   has now been corrected.

o  When using the "notify" option with the "play" command of the MCI command
   set, the MCI driver would play the animation correctly, but the
   notification message would indicate a failure to reach the destination
   frame. This has now been corrected.

o  The compilers now generate slightly different "Delta Image" chunks if
   you feed them a series of identical images. The new chunks are slightly
   more compact. The real reason to change the encoding, however, is that
   Autodesk's AAPLAY.DLL could crash on the previous encoding. (The previous
   encoding was technically correct; this is not really a bug fix in our
   product, it is a circumvention of a bug in AAPLAY.)

o  A bug in loading 24-bit BMP images was fixed.


New in version 2.1
------------------
Version 2.1 is a corrective update. A number of problems that were detected
or reported since the release of version 2.0 have been fixed. There are
relatively few new features.

o  A "gradual decelleration" problem was fixed. If you slowed down a FLIC file
   frame by frame, the playback could become *faster* instead of slower,
   because the player DLL took the spped into account one frame late.

o  A few palette problems (where the mapping of a palette could change, even
   if the palette itself stayed unaltered) were fixed.

o  The player set the bounding box to negative values if a "delta frame"
   (a FLI_SS chunk) had zero lines to update. On some systems, this resulted
   in a black line below or to the right of the animation.

o  The decompiler would set the time-per-frame of decoded FLI files too low.
   This is now fixed.

o  The compilers, decompiler and script generator now support the "SPRITE"
   file format of Cosmigo's Pro Motion. The decompiler generates one sprite
   file for every segment in the FLIC file.

o  The compiler now also supports the "#include" instruction in a segment,
   which is convenient if you wish to maintain small scripts for each segment.
   That is, now you can say:

        segment(
            label( hello )
            #include "hello.scr"
        )
        segment(
            label( goodbye )
            #include "goodbye.scr"
        )

o  A new instruction "#makescript", which generates a temporary script file
   from a pattern and then includes it. For example, if you wish to create
   an animation with two segments and you store the picture files for these
   segments in two separate directories, the script would be similar to:

        segment(
            #makescript "c:\pictures\first\*.pcx"
        )
        segment(
            #makescript "c:\pictures\second\*.pcx"
        )

   The #makescript instruction can also ananyze and create a script for a
   "Sprite" file by Pro Motion. If you have Pro Motion, the combination of
   the #makescript instruction and the sprite file support is perhaps the
   most convenient way to create multi-segment animations.

o  There are several small corrections in the "glue files" for Visual Basic
   and Borland Delphi.

o  Function FlicCreateWindow(), which creates a palette-aware window to play
   a FLIC file in, went through several modifications:
   1. This window now forwards the notification messages to its parent (if
      the window has a parent).
   2. The window no longer erases its background (which avoids flashing).
   3. The last parameter ("hInstance") is renamed to "reserved" and ignored.
      It turns out that the EPLAY DLLs do not need this argument.

o  A few instructions and parameter codes have been renamed. The "userdata"
   instruction is now called "userstring". Notification codes and data access
   codes with the strings "USER" or "USERDATA" in them now all contain
   "USERSTRING". There is a new constant "FLIC_DATA_USERDATA", which can be
   set with the new function "FlicSetData". Its purpose is similar to the
   user data in AniSprite: to contain any pointer value that a programmer
   might attach to an animation.


EGI 2.0 has the following new features:
---------------------------------------

o  Support for password protection. Caution: you cannot play back or
   decompile a FLIC for which you have forgotten the password.

o  You can add digitized audio to the animation (from .WAV files). Both
   unsynchronized sound (sound effects) and synchronized sound is
   supported.

o  FLIC animations can now run from memory. This frees a file handle; by
   default, a program has 20 file handles with 5 of them predefined and
   pre-opened. You can also play a FLIC file from a resource or from an
   archive file, provided that you load the resource/file into memory
   yourself.

o  An MCI driver is now included.

o  Ability to seek (forward and backward) to any frame in a segment.

o  You can now specify the "sequence" relations between segments. This
   allows you o combine several segments to a larger "meta-animation".

o  The player DLL can dynamically scale the image to any size. This is
   convenient to adjust the aspect ratio of FLI files to a resolution with
   square pixels (like 640x480 or 800x600). The player also scales the
   new "multilevel" masks (see below).

o  The compiler accepts 24-bit RGB images as input. It creates an optimal
   palette for these images, or it uses the palette that you specify.

o  EGIRUN replaces PTEST as the sample program. EGIRUN has more options
   and gives more information on FLIC files that PTEST, and it can also be
   used to test your FLIC files. PTEST is still provided, but in source form
   only. Of course, EGIRUN comes with full source as well.

o  The compiler supports cropping and panning of the input images. This is
   also convenient for filmstrips.

o  Support for multilevel masks (for sprite engines like AniSprite). The
   "bitmap" masks of the previous releases are also still supported.

o  For extensions that we did not think of, the EGI tools now support user
   data. This is a string that you can add to any frame.

o  The Windows version of the compiler has been much improved. It comes
   with online help.



These are in addition to the features already offered by EGI 1.2:
-----------------------------------------------------------------

o  The player is a DLL that you control from your application.
   Versions are available for Microsoft Windows 3.1, and for Microsoft
   Windows 95 and Windows NT (using threads and DIB sections). There is
   limited support for Win32s.

o  EGI can be integrated with a sprite library with little effort. This will
   allow you to make a FLIC animation of a walking puppet, and then to move
   that puppet across the screen like a sprite.

o  Synchronize animations with sound or other events. Options for "hard"
   and "soft" synchronization are supported.

o  Better compression with a last pass using Huffman coding and the
   Burrows-Wheeler Transform. The modified (and optimized) algorithm that
   EGI uses takes little CPU time to expand the data to the original size.

o  Palettes are optionally remapped to an "identity palette", which allows
   faster animation in Microsoft Windows. The animation can also adapt to the
   current foreground palette (even dynamically) or to an explicit palette.

o  Support for transparent animations.

o  Support for symbolic constants and shared include files for the EGI
   compiler and C programs (that use the EGI player to play back the
   animations).

o  A "decompiler" allows you to extract images (and a script file) from an
   existing FLIC file (both the .FLI and .FLC types are supported). You can
   feed these images back into the EGI compiler.

o  Interfaces for: C, C++, Delphi and Visual Basic.

o  Full source is available (for the players and for the compiler/decompiler).



COMMERCIAL INFORMATION
----------------------

EGI version 2.1 is available as of July 1998. To order EGI version 2.2,
use the order form (file ORDER.FRM in the archive) in the evaluation version,
or ask us to send or fax you an order form.


1. Contents of the product

EGI version 2.2 consists of:

  FLIC compiler (DOS and Windows versions)
  FLIC decompiler
  script generator
  FLIC players (DLLs) for Windows 3.1, Windows 95 and Windows NT
  FLIC MCI drivers for Windows 3.1, Windows 95 and Windows NT
  development libraries, programming examples
  printed manual

The decompiler converts a FLIC file into a series of PCX images and a script
file. It is provided to aid converting existing FLIC files to the enhanced
format used by EGI, in order to take advantage of features offered by EGI that
are not provided with other tools.


2. Price information

All prices are in Dutch Guilders (NLG). Approximate prices in Dollars
are given between parentheses, based on an exchange rate of 1.90 Dutch
Guilder for every Dollar.

Several license are available. The costs for shipping and handling
is NLG 45,00.


EGI standard license                              NLG 290,00
                                                  ($ 155.=)
   Includes:
          EGI compilers
          EGI decompiler
          EGI script generator
          EGI player in both 16-bit and 32-bit versions
          FLIC MCI drivers
          manual

   The EGI players may be distributed (without royalties) in combination
   with an application or development tool that uses the EGI player. The
   EGI compiler, decompiler, manual, examples or development files may
   not be distributed (and only be duplicated for backup purposes).


EGI source code license                           NLG 700,00
                                                  ($ 370.=)
   Includes:
          EGI compilers, including source
          EGI decompiler, including source
          EGI script generator, including source
          EGI players in both 16-bit and 32-bit versions,
            including source
          FLIC MCI drivers, including source
          manual

   Libraries and source code that are licensed from other parties are
   not included (this includes the run-time library of the C compiler).

   Modified, or unmodified, versions of the EGI compiler may not be
   resold or distributed. Modified, or unmodified, versions of the
   EGI players may be distributed only in executable form and only in
   combination with an application that uses the EGI player(s). The
   manual or other development files may not be resold or distributed.


Royalty free distribution of EGI compiler & manual: to be negotiated

   This license gives you the right, under certain conditions, to
   distribute the compiler, the decompiler, and the 16-bit and
   32-bit players. The EGI manual may still not be duplicated or
   distributed. The precise terms and conditions, as well as the
   price of this license are to be negotiated. Below are some
   guidelines to such a license.

   The EGI compiler, decompiler and players may only be distributed
   together with an application or development tool that uses the
   EGI compiler and the EGI players. The price for the license to
   distribute the product is as of NLG 4.000,-- but depends on
   how your product relates to EGI.

   You will not obtain an exclusive license to distribute EGI. That
   is, others may also negotiated a license with us to distribute
   the compiler, decompiler and players.

   If you have licensed EGI with source code, this "royalty free
   distribution" license also gives you the right to sell modified
   versions of the EGI compiler and players, but again, only if they
   are packaged together with an application or development tools
   that uses the EGI compiler and/or player.

   This option requires a signed license agreement.

