307 lines
10 KiB
C
307 lines
10 KiB
C
/* $NetBSD: grfabs_reg.h,v 1.5 1996/04/21 21:11:31 veego Exp $ */
|
|
|
|
/*
|
|
* Copyright (c) 1994 Christian E. Hopps
|
|
* All rights reserved.
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following conditions
|
|
* are met:
|
|
* 1. Redistributions of source code must retain the above copyright
|
|
* notice, this list of conditions and the following disclaimer.
|
|
* 2. Redistributions in binary form must reproduce the above copyright
|
|
* notice, this list of conditions and the following disclaimer in the
|
|
* documentation and/or other materials provided with the distribution.
|
|
* 3. All advertising materials mentioning features or use of this software
|
|
* must display the following acknowledgement:
|
|
* This product includes software developed by Christian E. Hopps.
|
|
* 4. The name of the author may not be used to endorse or promote products
|
|
* derived from this software without specific prior written permission
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
|
|
* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
|
|
* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
|
|
* IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
|
|
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
|
|
* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
|
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
|
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
|
|
* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
*/
|
|
|
|
#if ! defined (_GRFABS_REG_H)
|
|
#define _GRFABS_REG_H
|
|
|
|
struct point {
|
|
long x;
|
|
long y;
|
|
};
|
|
typedef struct point point_t;
|
|
|
|
struct dimension {
|
|
u_long width;
|
|
u_long height;
|
|
};
|
|
typedef struct dimension dimen_t;
|
|
|
|
struct box {
|
|
long x;
|
|
long y;
|
|
u_long width;
|
|
u_long height;
|
|
};
|
|
typedef struct box box_t;
|
|
|
|
struct rectangle {
|
|
long left;
|
|
long top;
|
|
long right;
|
|
long bottom;
|
|
};
|
|
|
|
typedef struct rectangle rect_t;
|
|
|
|
typedef struct bitmap bmap_t;
|
|
typedef struct colormap colormap_t;
|
|
typedef struct view view_t;
|
|
typedef struct display_mode dmode_t;
|
|
typedef struct monitor monitor_t;
|
|
|
|
LIST_HEAD(monitor_list, monitor);
|
|
extern struct monitor_list *monitors;
|
|
|
|
/*
|
|
* Bitmap stuff.
|
|
*/
|
|
|
|
/*
|
|
* Note structure is 5 long words big. This may come in handy for
|
|
* contiguous allocations
|
|
*
|
|
* Please do fill in everything correctly this is the main input for
|
|
* all other programs. In other words all problems with RTG start here.
|
|
* If you do not mimic everyone else exactly problems will appear.
|
|
* If you need a template look at alloc_bitmap() in grf_cc.c.
|
|
*
|
|
* WARNING: the plane array is only for convience, all data for bitplanes
|
|
* MUST be contiguous. This is for mapping purposes. The reason
|
|
* for the plane pointers and row_mod is to support interleaving
|
|
* on monitors that wish to support this.
|
|
*
|
|
* 2nd Warning: Also don't get funky with these pointers you are expected
|
|
* to place the start of mappable plane data in ``hardware_address'',
|
|
* ``hardware_address'' is the only thing that /dev/view checks and it
|
|
* expects the planes to follow with no padding in between. If you have
|
|
* special alignment requirements make use of the given fields
|
|
* so that the entire contiguous plane data is exactly:
|
|
* bytes_per_row*height*depth long starting at the physical address
|
|
* contained within hardware_address.
|
|
*
|
|
* Final Warning: Plane data must begin on a PAGE address and the allocation
|
|
* must be ``n'' PAGES big do to mapping requirements (otherwise the
|
|
* user could write over non-allocated memory.
|
|
*
|
|
*/
|
|
struct bitmap {
|
|
u_short bytes_per_row; /* number of bytes per display row. */
|
|
u_short row_mod; /* number of bytes to reach next row. */
|
|
u_short rows; /* number of display rows. */
|
|
u_short depth; /* depth of bitmap. */
|
|
u_short flags; /* flags. */
|
|
u_short pad;
|
|
u_char *blit_temp; /* private monitor buffer. */
|
|
u_char **plane; /* plane data for bitmap. */
|
|
u_char *hardware_address; /* mappable bitplane pointer. */
|
|
};
|
|
|
|
enum bitmap_flag_bits {
|
|
BMB_CLEAR, /* init only. */
|
|
BMB_INTERLEAVED, /* init/read. */
|
|
BMB_ALIGN64, /* init/read. */
|
|
};
|
|
|
|
enum bitmap_flags {
|
|
BMF_CLEAR = 1 << BMB_CLEAR, /* init only. */
|
|
BMF_INTERLEAVED = 1 << BMB_INTERLEAVED, /* init/read. */
|
|
BMF_ALIGN64 = 1 << BMB_ALIGN64 /* init/read. */
|
|
};
|
|
|
|
/* Use these macros to find misc. sizes of actual bitmap */
|
|
#define BM_WIDTH(b) ((b)->bytes_per_row << 3)
|
|
#define BM_HEIGHT(b) ((b)->rows)
|
|
#define BM_ROW(b,p,l) \
|
|
((b)->plane[p] + (((b)->bytes_per_row + (b)->row_mod) * l))
|
|
|
|
/*
|
|
* Colormap stuff.
|
|
*/
|
|
|
|
/*
|
|
* valid masks are a bitfield of zeros followed by ones that indicate
|
|
* which mask are valid for each component. The ones and zeros will
|
|
* be contiguous so adding one to this value yields the number of
|
|
* levels for that component.
|
|
* -ch
|
|
*/
|
|
|
|
struct colormap {
|
|
u_char type; /* what type of entries these are. */
|
|
union {
|
|
/* CM_GREYSCALE */
|
|
u_char grey;
|
|
#define grey_mask valid_mask.grey
|
|
/* CM_COLOR */
|
|
struct {
|
|
u_char red;
|
|
#define red_mask valid_mask.rgb_mask.red
|
|
u_char green;
|
|
#define green_mask valid_mask.rgb_mask.green
|
|
u_char blue;
|
|
#define blue_mask valid_mask.rgb_mask.blue
|
|
} rgb_mask;
|
|
} valid_mask;
|
|
u_short first; /* what color register does entry[0] refer to. */
|
|
u_short size; /* number of entries */
|
|
u_long *entry; /* the table of actual color values. */
|
|
};
|
|
|
|
enum colormap_type {
|
|
CM_MONO, /* only on or off allowed */
|
|
CM_GREYSCALE, /* grey vals. */
|
|
CM_COLOR /* RGB vals. */
|
|
};
|
|
|
|
#define CM_FIXVAL(x) (0xff & (x))
|
|
|
|
/* these macros are for creating entries */
|
|
#define MAKE_COLOR_ENTRY(r,g,b) \
|
|
(CM_FIXVAL(r) << 16 | CM_FIXVAL(g) << 8 | CM_FIXVAL(b))
|
|
#define MAKE_MONO_ENTRY(x) ((x) ? 1 : 0)
|
|
#define MAKE_GREY_ENTRY(l) CM_FIXVAL(l)
|
|
|
|
#define CM_LTOW(v) \
|
|
(((0x000F0000 & (v)) >> 8) | ((0x00000F00 & (v)) >> 4) | (0xF & (v)))
|
|
#define CM_WTOL(v) \
|
|
(((0xF00 & (v)) << 8) | ((0x0F0 & (v)) << 4) | (0xF & (v)))
|
|
|
|
/*
|
|
* View stuff.
|
|
*/
|
|
typedef void remove_view_func (view_t *v);
|
|
typedef void free_view_func (view_t *v);
|
|
typedef void display_view_func (view_t *v);
|
|
typedef dmode_t *get_mode_func (view_t *v);
|
|
typedef int get_colormap_func (view_t *v, colormap_t *);
|
|
typedef int use_colormap_func (view_t *v, colormap_t *);
|
|
|
|
struct view {
|
|
bmap_t *bitmap; /* bitmap. */
|
|
box_t display; /* viewable area. */
|
|
void *data; /* view specific data. */
|
|
|
|
/* functions */
|
|
display_view_func *display_view; /* make this view active */
|
|
remove_view_func *remove_view; /* remove this view if active */
|
|
free_view_func *free_view; /* free this view */
|
|
get_mode_func *get_display_mode;/* get the mode this view belongs to */
|
|
get_colormap_func *get_colormap; /* get a color map for registers */
|
|
use_colormap_func *use_colormap; /* use color map to load registers */
|
|
};
|
|
|
|
#define VDISPLAY_LINE(v, p, l) ((v)->bitmap->plane[(p)] +\
|
|
(((v)->bitmap->bytes_per_row + (v)->bitmap->row_mod) * l))
|
|
|
|
/*
|
|
* Mode stuff
|
|
*/
|
|
|
|
typedef view_t *alloc_view_func (dmode_t *mode, dimen_t *dim, u_char depth);
|
|
typedef view_t *get_current_view_func (dmode_t *);
|
|
typedef monitor_t *get_monitor_func (dmode_t *);
|
|
|
|
struct display_mode {
|
|
LIST_ENTRY(display_mode) link;
|
|
u_char *name; /* logical name for mode. */
|
|
dimen_t nominal_size; /* best fit. */
|
|
void *data; /* mode specific flags. */
|
|
alloc_view_func *alloc_view; /* allocate a view for this mode. */
|
|
get_current_view_func *get_current_view; /* get active view. */
|
|
get_monitor_func *get_monitor; /* get monitor that mode belongs to */
|
|
};
|
|
|
|
/*
|
|
* Monitor stuff.
|
|
*/
|
|
typedef void vbl_handler_func (void *);
|
|
typedef dmode_t *get_next_mode_func (dmode_t *);
|
|
typedef dmode_t *get_current_mode_func (void);
|
|
typedef dmode_t *get_best_mode_func (dimen_t *size, u_char depth);
|
|
typedef bmap_t *alloc_bitmap_func (u_short w, u_short h, u_short d, u_short f);
|
|
typedef void free_bitmap_func (bmap_t *bm);
|
|
|
|
struct monitor {
|
|
LIST_ENTRY(monitor) link; /* a link into the database. */
|
|
u_char *name; /* a logical name for this monitor. */
|
|
void *data; /* monitor specific data. */
|
|
get_current_mode_func *get_current_mode;
|
|
vbl_handler_func *vbl_handler; /* called on every vbl if not NULL */
|
|
get_next_mode_func *get_next_mode; /* return next mode in list */
|
|
get_best_mode_func *get_best_mode; /* return mode that best fits */
|
|
|
|
alloc_bitmap_func *alloc_bitmap;
|
|
free_bitmap_func *free_bitmap;
|
|
};
|
|
|
|
/*
|
|
* Misc draw related macros.
|
|
*/
|
|
|
|
#define BOX_2_RECT(b,r) do { \
|
|
(r)->left = (b)->x; (r)->top = (b)->y; \
|
|
(r)->right = (b)->x + (b)->width -1; \
|
|
(r)->bottom = (b)->y + (b)->height -1; \
|
|
} while (0)
|
|
|
|
#define RECT_2_BOX(r,b) do { \
|
|
(b)->x = (r)->left; \
|
|
(b)->y = (r)->top; \
|
|
(b)->width = (r)->right - (r)->left +1; \
|
|
(b)->height = (r)->bottom - (r)->top +1; \
|
|
} while(0)
|
|
|
|
#define INIT_BOX(b,xx,yy,ww,hh) do{(b)->x = xx; (b)->y = yy; (b)->width = ww; (b)->height = hh;}while (0)
|
|
#define INIT_RECT(rc,l,t,r,b) do{(rc)->left = l; (rc)->right = r; (rc)->top = t; (rc)->bottom = b;}while (0)
|
|
#define INIT_POINT(p,xx,yy) do {(p)->x = xx; (p)->y = yy;} while (0)
|
|
#define INIT_DIM(d,w,h) do {(d)->width = w; (d)->height = h;} while (0)
|
|
|
|
|
|
/*
|
|
* Prototypes
|
|
*/
|
|
|
|
/* views */
|
|
view_t * grf_alloc_view __P((dmode_t *d, dimen_t *dim, u_char depth));
|
|
void grf_display_view __P((view_t *v));
|
|
void grf_remove_view __P((view_t *v));
|
|
void grf_free_view __P((view_t *v));
|
|
dmode_t *grf_get_display_mode __P((view_t *v));
|
|
int grf_get_colormap __P((view_t *v, colormap_t *cm));
|
|
int grf_use_colormap __P((view_t *v, colormap_t *cm));
|
|
|
|
/* modes */
|
|
view_t *grf_get_current_view __P((dmode_t *d));
|
|
monitor_t *grf_get_monitor __P((dmode_t *d));
|
|
|
|
/* monitors */
|
|
dmode_t * grf_get_next_mode __P((monitor_t *m, dmode_t *d));
|
|
dmode_t * grf_get_current_mode __P((monitor_t *));
|
|
dmode_t * grf_get_best_mode __P((monitor_t *m, dimen_t *size, u_char depth));
|
|
bmap_t * grf_alloc_bitmap __P((monitor_t *m, u_short w, u_short h,
|
|
u_short d, u_short f));
|
|
void grf_free_bitmap __P((monitor_t *m, bmap_t *bm));
|
|
|
|
int grfcc_probe __P((void));
|
|
|
|
#endif /* _GRFABS_REG_H */
|