Return to bitblt_aed.h CVS log

Up to [CSRG BSD Unix] / 43BSDTahoe / new / X / libibm / bitblt

Annotation of 43BSDTahoe/new/X/libibm/bitblt/bitblt_aed.h, revision 1.1

1.1     ! root        1: /* $Header: bitblt_aed.h,v 10.1 86/11/19 10:51:37 jg Exp $ */
        !             2: /* aed.h - Defines and macros needed to support AED
        !             3:  *
        !             4:  *     Author:
        !             5:  *             Scott Bates
        !             6:  *             Brown University
        !             7:  *             IRIS, Box 1946
        !             8:  *             Providence, RI 02912
        !             9:  *
        !            10:  *
        !            11:  *             Copyright (c) 1986 Brown University
        !            12:  *
        !            13:  * Permission to use, copy, modify and distribute this software and its
        !            14:  * documentation for any purpose and without fee is hereby granted, provided
        !            15:  * that the above copyright notice appear in all copies, and that both
        !            16:  * that copyright notice and this permission notice appear in supporting
        !            17:  * documentation, and that the name of Brown University not be used in
        !            18:  * advertising or publicity pertaining to distribution of the software
        !            19:  * without specific, written prior permission. Brown University makes no
        !            20:  * representations about the suitability of this software for any purpose.
        !            21:  * It is provided "as-is" without express or implied warranty.
        !            22:  */
        !            23: 
        !            24: #define AED_BM_ADDR    0xEF100000
        !            25: #define AED_WIDTH      1024
        !            26: #define AED_HEIGHT     800
        !            27: #define AED_BM_SIZE    (((((AED_WIDTH/8) * AED_HEIGHT) + 2047) / 2048) * 2048)
        !            28: #define AED_COLOR      ((int *)(AED_BM_ADDR + AED_BM_SIZE + 0))
        !            29: #define AED_CMDQ_SEMA  (*((int *)(AED_BM_ADDR + AED_BM_SIZE + 4)))
        !            30: #define AED_CMDQ_INDEX (*((int *)(AED_BM_ADDR + AED_BM_SIZE + 8)))
        !            31: #define AED_CMDQ       ((struct aed_cmd *)(AED_BM_ADDR + AED_BM_SIZE + 128))
        !            32: 
        !            33: #define AED_CMD_SIZE   64      /* size of a command on queue */
        !            34: #define AED_MAX_CMDS   ((2048 - 128) / AED_CMD_SIZE)
        !            35: 
        !            36: /*
        !            37:  * Types of aed commands
        !            38:  */
        !            39: 
        !            40: #define AED_ECHO_RECT  1
        !            41: #define AED_DRAW_LINE  2
        !            42: #define AED_SCREEN_COPY        3
        !            43: 
        !            44: /*
        !            45:  * echo a rectangle from the simulated bitmap to the display.
        !            46:  */
        !            47: 
        !            48: struct aed_echo_rect {
        !            49:        short origin_y;
        !            50:        short origin_x;
        !            51:        short corner_y;
        !            52:        short corner_x;
        !            53: };
        !            54: 
        !            55: /*
        !            56:  * draw a line
        !            57:  */
        !            58: 
        !            59: struct aed_draw_line {
        !            60:        short   from_x;
        !            61:        short   from_y;
        !            62:        short   to_x;
        !            63:        short   to_y;
        !            64:        short   rule;
        !            65:        short   width;
        !            66:        short   color;
        !            67:        u_short pat;
        !            68:        short   patlen;
        !            69:        short   top;
        !            70:        short   left;
        !            71:        short   bottom;
        !            72:        short   right;
        !            73: };
        !            74: 
        !            75: /*
        !            76:  * screen to screen copy
        !            77:  */
        !            78: 
        !            79: struct aed_screen_copy {
        !            80:        short from_x;
        !            81:        short from_y;
        !            82:        short to_x;
        !            83:        short to_y;
        !            84:        short width;
        !            85:        short height;
        !            86:        short rule;
        !            87: };
        !            88: 
        !            89: /*
        !            90:  * AED command struct
        !            91:  */
        !            92: 
        !            93: struct aed_cmd {
        !            94:        long cmd;
        !            95:        union cmd_block {
        !            96:                struct aed_echo_rect echo_rect;
        !            97:                struct aed_draw_line draw_line;
        !            98:                struct aed_screen_copy screen_copy;
        !            99:        } aed_cmd_block;
        !           100:        char padding[AED_CMD_SIZE - sizeof(long) - sizeof(union cmd_block)];
        !           101: };
        !           102: 
        !           103: #define ECHO_RECT      aed_cmd_block.echo_rect
        !           104: #define SCREEN_COPY    aed_cmd_block.screen_copy
        !           105: #define DRAW_LINE      aed_cmd_block.draw_line
        !           106: 
        !           107: /*
        !           108:  * map bltter combination rule to AED combination rule
        !           109:  */
        !           110: 
        !           111: static u_char aed_rules[16] = {
        !           112:        0, 8, 4, 12, 2, 10, 6, 14,
        !           113:        1, 9, 5, 13, 3, 11, 7, 15,
        !           114: };
        !           115: 
        !           116: #define AED_RULE(x_rule) (((u_short)aed_rules[x_rule]) & 0x0F)

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.