/* rast.h - header file for Sun raster files
**
** The format of a Sun raster file is as follows.  First, a struct
** rasterfile.  Note the 32-bit magic number at the beginning; this
** identifies the file type and lets you figure out whether you need
** to do little-endian / big-endian byte-swapping or not.  (The PBMPLUS
** implementation does not do byte-swapping; instead, it reads all
** multi-byte values a byte at a time.)
**
** After the struct is an optional colormap.  If ras_maptype is RMT_NONE,
** no map is present; if it's RMT_EQUAL_RGB then the map consists of
** three unsigned-char arrays ras_maplength long, one each for r g and b.
** I don't know what RMT_RAW means.  Black and white bitmaps are stored
** as ras_maptype == RMT_NONE and ras_depth == 1, with the bits stored
** eight to a byte MSB first.
**
** Finally comes the image data.  If ras_type is RT_OLD or RT_STANDARD,
** the data is just plain old uncompressed bytes, padded out to a multiple
** of 16 bits in each row.  If ras_type is RT_BYTE_ENCODED, a run-length
** compression scheme is used: an escape-byte of 128 indicates a run;
** the next byte is a count, and the one after that is the byte to be
** replicated.  The one exception to this is if the count is 1; then
** there is no third byte in the packet, it means to put a single 128
** in the data stream.
*/

#ifndef RAST_H_INCLUDED
#define RAST_H_INCLUDED

#define PIX_ERR         -1

struct rasterfile {
    long ras_magic;
#define RAS_MAGIC       0x59a66a95
    long ras_width;
    long ras_height;
    long ras_depth;
    long ras_length;
    long ras_type;
#define RT_OLD          0       /* Raw pixrect image in 68000 byte order */
#define RT_STANDARD     1       /* Raw pixrect image in 68000 byte order */
#define RT_BYTE_ENCODED 2       /* Run-length compression of bytes */
#define RT_FORMAT_RGB   3       /* XRGB or RGB instead of XBGR or BGR */
#define RT_FORMAT_TIFF  4       /* tiff <-> standard rasterfile */
#define RT_FORMAT_IFF   5       /* iff (TAAC format) <-> standard rasterfile */
#define RT_EXPERIMENTAL 0xffff  /* Reserved for testing */
    long ras_maptype;
#define RMT_NONE        0
#define RMT_EQUAL_RGB   1
#define RMT_RAW         2
    long ras_maplength;
};

struct pixrectops {
    int (*pro_rop)();
    int (*pro_stencil)();
    int (*pro_batchrop)();
    int (*pro_nop)();
    int (*pro_destroy)();
    int (*pro_get)();
    int (*pro_put)();
    int (*pro_vector)();
    struct pixrect* (*pro_region)();
    int (*pro_putcolormap)();
    int (*pro_getcolormap)();
    int (*pro_putattributes)();
    int (*pro_getattributes)();
};

struct pr_size {
    int x, y;
};

struct pr_pos {
    int x, y;
};

struct pixrect {
    struct pixrectops* pr_ops;
    struct pr_size pr_size;
    int pr_depth;
    struct mpr_data* pr_data;   /* work-alike only handles memory pixrects */
};

struct mpr_data {
    int md_linebytes;
    unsigned char* md_image;    /* note, byte not short -- avoid pr_flip() */
    struct pr_pos md_offset;
    short md_primary;
    short md_flags;
};

typedef struct {
    int type;
    int length;
    unsigned char* map[3];
} colormap_t;

/* And the routine definitions. */

struct pixrect *
mem_create(int const w,
           int const h,
           int const depth);

void
mem_free(struct pixrect * const p);

int
pr_dump(struct pixrect * const p,
        FILE *           const out,
        colormap_t *     const colormap,
        int              const type,
        int              const copy_flag);

int
pr_load_header(FILE *              const in,
               struct rasterfile * const hP);

int
pr_load_colormap(FILE *              const in,
                 struct rasterfile * const hP,
                 colormap_t *        const colormap);

struct pixrect *
pr_load_image(FILE *              const in,
              struct rasterfile * const hP,
              colormap_t *        const colormap);

#endif