Hermes 1.3 API
Christian Nentwich (brn), c.nentwich@cs.ucl.ac.uk
04/12/1998
This is the API documentation for the HERMES pixel format conversion
library. HERMES is (c)1998 Christian Nentwich and other (see CONTRIB).
This package is licensed under the GNU LGPL. Refer to COPYING.LIB for
exact terms and conditions
______________________________________________________________________
Table of Contents
1. Initialisation of the Library
1.1 int Hermes_Init()
1.2 int Hermes_Done()
2. Palette Handling
2.1 HermesHandle Hermes_PaletteInstance()
2.2 void Hermes_PaletteReturn(HermesHandle handle)
2.3 void Hermes_PaletteSet(HermesHandle handle,int32 *palette)
2.4 int32* Hermes_PaletteGet(HermesHandle handle)
2.5 void Hermes_PaletteInvalidateCache(HermesHandle handle)
3. Format Conversion
3.1 HermesHandle Hermes_ConverterInstance(unsigned long flags)
3.2 void Hermes_ConverterReturn(HermesHandle handle)
3.3 int Hermes_ConverterRequest(...)
3.4 int Hermes_ConverterPalette(...)
3.5 int Hermes_ConverterCopy(...)
4. Surface Clearing
4.1 HermesHandle Hermes_ClearerInstance()
4.2 void Hermes_ClearerReturn(HermesHandle handle)
4.3 int Hermes_ClearerRequest(HermesHandle handle,HermesFormat *format)
4.4 int Hermes_ClearerClear(...)
______________________________________________________________________
1. Initialisation of the Library
Hermes has to be fully initialised before any conversion routines can
be called. Otherwise error codes will be returned. All initialisation
routines are reference counted, so feel free to call them repeatedly,
they will only be initialised once (or if you closed it down and open
it again).
1.1. int Hermes_Init()
Hermes_Init will initialise Hermes and return a non-zero status code
on success. In detail, this is what happens:
o Check reference count. If non-zero, return success immediately.
o If assembler support is compiled in, run the processor detection
routine. Hold your breath.
o Call the Converter Factory to initialise all converters with the
fastest possible configuration.
o Initialise clearing routines using the Clearing Factory.
o Initialise dithering matrices.
o Increase reference count, return success.
1.2. int Hermes_Done()
Hermes_Done will decrease the reference count of HERMES and if it goes
down to zero, it will deinitialise the library. That means it will get
rid of all the converter routines, etc.
If the reference count ever falls below zero, this routine will return
an error because you've done something wrong.
2. Palette Handling
If you want to use 8 bit indexed modes, you will have to use palettes.
Also, if you want to use indexed modes, you will have to tell HERMES
what palette you are using so it can create lookup tables, and so on.
HERMES needs lookup tables in order to convert efficiently from 8 bit
to other formats without worrying you. If you just make a few function
calls, HERMES will make sure your 8 bit mode works on any other mode.
As a last remark, palettes are stored as 8 bit per colour component
values, NOT 6 bit. Keep it in mind.
2.1. HermesHandle Hermes_PaletteInstance()
This function returns a handle for you to use in subsequent palette
handling operations. It will return zero on failure. Store this handle
somewhere, you will need it for the following functions. This has to
be the first function to be called before any palette handling.
2.2. void Hermes_PaletteReturn(HermesHandle handle)
If you are finished, use this to return your palette. This will free
up the memory occupied by the palette and all the cached tables, etc.
If you pass an invalid handle, your call will be ignored.
2.3. void Hermes_PaletteSet(HermesHandle handle,int32 *palette)
Surely, if you have a palette, you might want to set it. Use this
function to copy 256 4-byte values from the pointer provided into the
internal HERMES palette specified by handle. It would be a wise thing
not to use this at all, i.e. not to store your own palette, but use
the one already in HERMES, otherwise you are storing everything twice.
In this case, look at the next function that says how to get access to
the internal palette. But read on for caveats.
If you call this function, HERMES will assume that your palette has
changed and flag all it's lookup tables invalid. So do NOT call it in
a loop or anything unless your palette really does change. Lookup
table recreation does not take place in there, however, but only when
you actually convert something.
CAVEAT: This is the only function that invalidates the lookup tables
of HERMES. If you use the next function, Hermes_PaletteGet, to get a
pointer and then modify the palette, HERMES will not know that it has
changed. Thus, any conversion to a non-indexed mode will draw garbage.
You can use the Hermes_PaletteInvalidateCache in this case to force
regeneration of lookup tables upon the next conversion.
2.4. int32* Hermes_PaletteGet(HermesHandle handle)
As said up there somewhere, it is probably wiser to let HERMES store
the palette you want to use as it has to do it anyway. You can use
this function to get a pointer to a 256-integer array of colour
values.
Feel free to modify the palette, but keep in mind what is written
above, you will trick HERMES and its lookup tables will be invalid.
Call the next function documented below to resolve this.
Also, HERMES will return 0 if you pass an invalid handle. Take care of
this as it will probably cause you a segmentation fault.
2.5. void Hermes_PaletteInvalidateCache(HermesHandle handle)
As described above, this function will cause HERMES to mark invalid
all its lookup tables. As a consequence, when the next conversion from
8 bit is done, one of them will have to be regenerated. (By the way,
'regenerate a lookup table' sounds like pulling your teeth out. It is
not. It's a minor thing, just a 256 byte table, no need to worry)
3. Format Conversion
There are a few steps involved in getting your buffers / images
converted. Initialisation, request for conversion, palette setting
and the actual conversion.
The routines below will normally be called in the following order to
do what they are supposed to do:
o Hermes_ConverterInstance
o Loop starts here:
o Hermes_ConverterRequest
o Hermes_ConverterPalette
o Hermes_ConverterCopy
o Go to Loop
o Hermes_ConverterReturn
You will have to call Hermes_ConverterPalette every time before
copying because your palette might have changed. And if there is a
conversion from 8 bit to a direct colour format then HERMES has to
update its lookup tables.
WARNING: Do not attempt to save time by not calling
Hermes_ConverterPalette or Hermes_ConverterRequest in your program's
main loop. You have nothing to be afraid of, HERMES caches everything
for you. If nothing changes, HERMES returns immediately. Omitting the
calls will only cause problems.
3.1. HermesHandle Hermes_ConverterInstance(unsigned long flags)
This will generate a new converter instance and return it to you. If
an error occurs, 0 will be returned instead. Don't forget to check. At
the moment, you can pass the following flags:
o HERMES_CONVERT_DITHER - Use dithering where appropriate and a
converter is available. That will make every effort to dither but
if it's an exotic conversion and no one has written the converter
yet, it will fall back to normal conversion
Additional notes: Hermes keeps a dynamic array of converter instances
that will grow if it runs out of space. You can change the default
size and growth of the array in HermConf.h before compiling.
Keep the handle this function returns somewhere safe, you will need it
for any other conversion function (and you can use it for locking if
you want to be thread safe!)
3.2. void Hermes_ConverterReturn(HermesHandle handle)
Return the conversion routine specified by handle to HERMES to free up
its spaces. This will get rid of all caches, lookup tables, etc.
associated with this converter. Try not to create and destroy
converters too often, it is costly. After all, the main effort in
HERMES was to shift everything from loop time to initialisation time.
HERMES will ignore attempts to return non-existing handles.
3.3. int Hermes_ConverterRequest(...)
Complete function declaration: Hermes_ConverterRequest(HermesHandle
handle, HermesFormat *source, HermesFormat *dest).
This will instruct Hermes to find a converter from the given source
format to the given destination format and store it in the structure
associated with handle. (Get a converter handle using
Hermes_ConverterInstance).
As mentioned before, don't be shy, call it every time before you call
Hermes_ConverterCopy unless you are really sure that the size of your
window, colour format etc. doesn't change. You don't have to be afraid
as any calls without changes will return success immediately.
The way HERMES will find your converter is the following:
o Check if anything has changed (colour formats, etc.). If no, return
o If the two colour formats are equal, return optimised converters
o Look for a specialised converter for the two formats
o If nothing has been found so far, find a generic converter
This function will return a non-zero value if a converter could be
found, otherwise zero will be returned.
3.4. int Hermes_ConverterPalette(...)
Complete function declaration: Hermes_ConverterPalette(HermesHandle
handle, HermesHandle sourcepal, HermesHandle destpal)
handle is the converter handle you got by using
Hermes_ConverterInstance(). sourcepal and destpal are two palette
handles which you have to get using Hermes_PaletteInstance().
This function will instruct HERMES to use the specified palettes for
format conversion. At the moment, only sourcepal is of interest. It
will be used whenever you want to convert from an indexed 8 bit format
to any destination format. You may pass the sourcepal handle as
destpal for the time being, it has no effect.
If converting from 8 bit to a non-indexed format, HERMES has to create
a lookup table. In order to prevent any cycle-wasting, HERMES will
cache those lookup tables for you. Whenever you change the palette,
however - using Hermes_PaletteSet - the lookup tables have to be
recalculated. In any case, generating lookup tables is a minor effort.
If any of the handles you pass are invalid or some other error occurs,
HERMES will return zero on this function. Otherwise any non-zero value
is returned.
3.5. int Hermes_ConverterCopy(...)
Complete function declaration: Hermes_ConverterCopy(HermesHandle
handle, void *s_pixels,int s_x,int s_y,int s_width,int s_height,int
s_pitch, void *d_pixels,int d_x,int d_y,int d_width,int d_height,int
d_pitch)
Now, this is the real things and it has so many parameters that I
might as well make a list out of them :)
o HermesHandle handle - the converter handle from
Hermes_ConverterInstance
o void *s_pixels - pointer to the beginning of your source buffer. It
is void because it might be any kind of format
o int s_x - x coordinate of top left corner in the source buffer, in
pixels, not bytes!
o int s_y - y coordinate of top left corner in the source buffer
o int s_width - width of the area of the source buffer to be
converted, in pixels!
o int s_height - height of the area of the source buffer to be
converted
o int s_pitch - the pitch of the source buffer, more below.
o void *d_pixels - pointer to the beginning of the destination buffer
o int d_x - x coordinate of top left corner in the destination
buffer, in pixels, not bytes!
o int d_y - y coordinate of top left corner in the destination buffer
o int d_width - width of the converted area in the destination
buffer, int pixels, not bytes!
o int d_height - height of the converted area in the destination
buffer
o int d_pitch - pitch of the destination buffer, more below
And, before I forget it, coordinates and widths up there are in
pixels, not bytes! (That should prevent you from making mistakes now
:)
The pitch of a buffer is basically the number of bytes in a scanline.
This is normally equal to the width of the scanline in pixels times
the number of bytes in a pixel. However, one some platforms this is
not true.. and somebody might want to align their scanlines and they
would find this quite comfortable.
In other words, the pitch is the amount in bytes to add to the
beginning of a scanline in order to get to the beginning of the next
scanline. Read again: amount in BYTES this time, NOT pixels. Beware!
There are a few things that can cause this function to return 0 (which
indicates an error):
1. You specified an invalid handle
2. The source width or source height does not match the destination
width or destination height AND no stretch converter can be found
From this, the policy of this function should be apparent but shall be
made a bit more explicit:
o If the dithering flag has been set, find a dithering routine,
otherwise fall back to normal
o If s_width!=d_width or s_height!=d_height then a stretching routine
has to be used
o Otherwise do a normal conversion
It is probably also worthwhile noting that even though this all has a
Converter prefix, if the source and destination formats are equal,
then straight copying will be used.
4. Surface Clearing
HERMES provides support for clearing surfaces (i.e. blocks of memory
filled with pixels) quickly and cleanly. Clearing routines exist in C,
x86 assembler and MMX assembler versions and thus are fast. However,
keep in mind that if you have the chance of using a hardware
accelerated routine for this, it will still be faster.
4.1. HermesHandle Hermes_ClearerInstance()
Not much to say about this, same as the other *Instance() functions.
You have to call this to obtain a handle before you use any other
clearing routines.
This routine can return zero upon failure.
4.2. void Hermes_ClearerReturn(HermesHandle handle)
Again, if you are finished clearing surfaces (and that means
completely finished, call it only at the end of a program, not every
time you have just cleared a surface) use this function to free up any
memory inside Hermes.
4.3. int Hermes_ClearerRequest(HermesHandle handle,HermesFormat *for-
mat)
This function will tell HERMES to prepare a special clearer for a
subsequent clear operation. Again, you may call this as often as you
want, once it has been set up, subsequent calls will be cached.
Zero will be returned if your handle is invalid or the format you
requested cannot be cleared (all formats are implemented, thus you
will have to request a pretty fucked up format in order to fail this
:). Upon success, any non-zero value may be returned.
4.4. int Hermes_ClearerClear(...)
ClearerClear is the function that actually does the work. The request
function has to be called before this, otherwise it will fail. The
following variables have to be passed to the function:
o HermesHandle handle - the handle you have obtained by calling
Hermes_ClearerInstance().
o void *pixels - the buffer to clear. It is void because it might be
any format that has been requested in Hermes_ClearerRequest()
o int x1 - Upper left corner x coordinate IN PIXELS not bytes
o int y1 - Upper left corner y coordinate in pixels
o int width - Width of area to be cleared in pixels
o int height - Height of area to be cleared in pixels
o int pitch - Amount IN BYTES to add in order to get from the
beginning of a scanline to the beginning of the next. See the
conversion section for more on this.
o int32 r - For direct colour, the red component, between 0-255 !!
o int32 g - For direct colour, green between 0-255
o int32 b - For direct colour, blue between 0-255
o char8 index - For indexed modes, the colour index to use for
clearing. For direct colour modes, the alpha value!
Hermes_ClearerClear returns any non-zero value on success. If zero is
returned, the clearing has failed, most of the time because the handle
you have passed was invalid.
