Defines one metainfo record. For example:
 {"JPEG 'COM' marker", "File written by Photoshop"}
struct fmt_metaentry
{
    Group name, for example "SGI Image name"
    std::string group;

    Information. For example "This image was created with MegaTool 0.5.1"
    std::string data;

};

Defines 32-bit pixel. Red, Green, Blue and Alpha channel.
struct RGBA
{
    RGBA() : r(0), g(0), b(0), a(0)
    {}

    RGBA(s32 r1, s32 g1, s32 b1, s32 a1) : r(r1), g(g1), b(b1), a(a1)
    {}

    u8 r;
    u8 g;
    u8 b;
    u8 a;
}PACKED;

Defines 24-bit color pixel. Red, Green, Blue.
struct RGB
{
    RGB() : r(0), g(0), b(0)
    {}

    RGB(s32 r1, s32 g1, s32 b1) : r(r1), g(g1), b(b1)
    {}

    u8 r;
    u8 g;
    u8 b;

}PACKED;

Defines one image. It stores the main information about one image: width,
height, metainfo, ...
struct fmt_image
{
    fmt_image() : w(0), h(0), bpp(0), hasalpha(false), needflip(false),
		    delay(0), interlaced(false), passes(1)
    {}

    width of the image
    s32                 w;
    height
    s32                 h;
    bits per pixel
    s32                 bpp;
    has alpha channel ?
    bool                hasalpha;
    flip ? (for example BMP needs)
    bool                needflip;
    only for animated images (like GIF)
    s32	                delay;
    Is it interlaced or normal ?
    bool		interlaced;
    Item 'passes' stores a number of passes if the image is iterlaced, or 1 otherwise.
    s32			passes;
    color space (RGB, RGBA, CMYK, LAB ...)
    std::string colorspace;
    compression type (RLE, JPEG, Deflate ...)
    std::string compression;

};

The main structure in ksquirrel-libs. It contains all information needed
to decode a file with one or more images.
struct fmt_info
{
    fmt_info() : animated(false)
    {}

    Array of fmt_image structures. One structure defines one image.
    std::vector<fmt_image>      image;

    Metainfo entries
    std::vector<fmt_metaentry>  meta;

    Is it animated or static ?
    bool		animated;

};


enum fmt_compression { 

No compression
CompressionNo = 1,

RLE compression
CompressionRLE = 2,

Internal cmpression. E.g. compression_level will be passed to internal routines,
for example in libjpeg, libpng.
Note: if the image can be compressed with RLE encoding and with only RLE
encoding, compression_scheme should be CompressionInternal
CompressionInternal = 4 };

Write options for image format
struct fmt_writeoptionsabs
{
    Can be interlaced ?
    bool interlaced;

    if interlaced, this value should store preferred number of passes.
    s32 passes;

    if the image should be flipped before writing
    bool needflip;

        with which compression it can be encoded ?
        for example: CompressionNo | CompressionRLE.
        it means, that image can be encoded with RLE
        method or can be saved without any compression.
    s32  compression_scheme;

        minimum compression level, maximum and default.
        For example, JPEG library has minimum = 0,
        maximum = 100 and default = 25.
    s32  compression_min, compression_max, compression_def;

}PACKED;

this information will be passed to writing function
struct fmt_writeoptions
{
    write interlaced image or normal ?
    bool interlaced;

    with which compression encode the image ?
    fmt_compression compression_scheme;

    compression level
    s32 compression_level;

    has alpha channel ? If no, A channel in RGBA image will be ignored
    bool alpha;

}PACKED;


We can use comparison operators for RGBA and RGB pixels. For example:

#define SQ_NEED_OPERATOR_RGBA_RGB

RGBA rgba;
RGB rgb;
...
if(rgba == rgb)
    printf("Pixels are equal!\n");

#if defined SQ_NEED_OPERATOR_RGBA_RGBA
static s32 operator== (const RGBA &rgba1, const RGBA &rgba2)
{
    return (rgba1.r == rgba2.r && rgba1.g == rgba2.g && rgba1.b == rgba2.b && rgba1.a == rgba2.a);
}
#endif

#if defined SQ_NEED_OPERATOR_RGB_RGBA
static s32 operator== (const RGB &rgb, const RGBA &rgba)
{
    return (rgb.r == rgba.r && rgb.g == rgba.g && rgb.b == rgba.b);
}
#endif

#if defined SQ_NEED_OPERATOR_RGBA_RGB
static s32 operator== (const RGBA &rgba, const RGB &rgb)
{
    return (rgba.r == rgb.r && rgba.g == rgb.g && rgba.b == rgb.b);
}
#endif

#endif