1: /*
    2:  * QEMU Cirrus CLGD 54xx VGA Emulator.
    3:  *
    4:  * Copyright (c) 2004 Fabrice Bellard
    5:  *
    6:  * Permission is hereby granted, free of charge, to any person obtaining a copy
    7:  * of this software and associated documentation files (the "Software"), to deal
    8:  * in the Software without restriction, including without limitation the rights
    9:  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
   10:  * copies of the Software, and to permit persons to whom the Software is
   11:  * furnished to do so, subject to the following conditions:
   12:  *
   13:  * The above copyright notice and this permission notice shall be included in
   14:  * all copies or substantial portions of the Software.
   15:  *
   16:  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
   17:  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
   18:  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
   19:  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
   20:  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
   21:  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
   22:  * THE SOFTWARE.
   23:  */
   24: 
   25: static void
   26: glue(cirrus_bitblt_rop_fwd_, ROP_NAME)(CirrusVGAState *s,
   27:                              uint8_t *dst,const uint8_t *src,
   28:                              int dstpitch,int srcpitch,
   29:                              int bltwidth,int bltheight)
   30: {
   31:     int x,y;
   32:     dstpitch -= bltwidth;
   33:     srcpitch -= bltwidth;
   34:     for (y = 0; y < bltheight; y++) {
   35:         for (x = 0; x < bltwidth; x++) {
   36:             ROP_OP(*dst, *src);
   37:             dst++;
   38:             src++;
   39:         }
   40:         dst += dstpitch;
   41:         src += srcpitch;
   42:     }
   43: }
   44: 
   45: static void
   46: glue(cirrus_bitblt_rop_bkwd_, ROP_NAME)(CirrusVGAState *s,
   47:                                         uint8_t *dst,const uint8_t *src,
   48:                                         int dstpitch,int srcpitch,
   49:                                         int bltwidth,int bltheight)
   50: {
   51:     int x,y;
   52:     dstpitch += bltwidth;
   53:     srcpitch += bltwidth;
   54:     for (y = 0; y < bltheight; y++) {
   55:         for (x = 0; x < bltwidth; x++) {
   56:             ROP_OP(*dst, *src);
   57:             dst--;
   58:             src--;
   59:         }
   60:         dst += dstpitch;
   61:         src += srcpitch;
   62:     }
   63: }
   64: 
   65: static void
   66: glue(glue(cirrus_bitblt_rop_fwd_transp_, ROP_NAME),_8)(CirrusVGAState *s,
   67:                                                        uint8_t *dst,const uint8_t *src,
   68:                                                        int dstpitch,int srcpitch,
   69:                                                        int bltwidth,int bltheight)
   70: {
   71:     int x,y;
   72:     uint8_t p;
   73:     dstpitch -= bltwidth;
   74:     srcpitch -= bltwidth;
   75:     for (y = 0; y < bltheight; y++) {
   76:         for (x = 0; x < bltwidth; x++) {
   77:             p = *dst;
   78:             ROP_OP(p, *src);
   79:             if (p != s->gr[0x34]) *dst = p;
   80:             dst++;
   81:             src++;
   82:         }
   83:         dst += dstpitch;
   84:         src += srcpitch;
   85:     }
   86: }
   87: 
   88: static void
   89: glue(glue(cirrus_bitblt_rop_bkwd_transp_, ROP_NAME),_8)(CirrusVGAState *s,
   90:                                                         uint8_t *dst,const uint8_t *src,
   91:                                                         int dstpitch,int srcpitch,
   92:                                                         int bltwidth,int bltheight)
   93: {
   94:     int x,y;
   95:     uint8_t p;
   96:     dstpitch += bltwidth;
   97:     srcpitch += bltwidth;
   98:     for (y = 0; y < bltheight; y++) {
   99:         for (x = 0; x < bltwidth; x++) {
  100:             p = *dst;
  101:             ROP_OP(p, *src);
  102:             if (p != s->gr[0x34]) *dst = p;
  103:             dst--;
  104:             src--;
  105:         }
  106:         dst += dstpitch;
  107:         src += srcpitch;
  108:     }
  109: }
  110: 
  111: static void
  112: glue(glue(cirrus_bitblt_rop_fwd_transp_, ROP_NAME),_16)(CirrusVGAState *s,
  113:                                                         uint8_t *dst,const uint8_t *src,
  114:                                                         int dstpitch,int srcpitch,
  115:                                                         int bltwidth,int bltheight)
  116: {
  117:     int x,y;
  118:     uint8_t p1, p2;
  119:     dstpitch -= bltwidth;
  120:     srcpitch -= bltwidth;
  121:     for (y = 0; y < bltheight; y++) {
  122:         for (x = 0; x < bltwidth; x+=2) {
  123:             p1 = *dst;
  124:             p2 = *(dst+1);
  125:             ROP_OP(p1, *src);
  126:             ROP_OP(p2, *(src+1));
  127:             if ((p1 != s->gr[0x34]) || (p2 != s->gr[0x35])) {
  128:                 *dst = p1;
  129:                 *(dst+1) = p2;
  130:             }
  131:             dst+=2;
  132:             src+=2;
  133:         }
  134:         dst += dstpitch;
  135:         src += srcpitch;
  136:     }
  137: }
  138: 
  139: static void
  140: glue(glue(cirrus_bitblt_rop_bkwd_transp_, ROP_NAME),_16)(CirrusVGAState *s,
  141:                                                          uint8_t *dst,const uint8_t *src,
  142:                                                          int dstpitch,int srcpitch,
  143:                                                          int bltwidth,int bltheight)
  144: {
  145:     int x,y;
  146:     uint8_t p1, p2;
  147:     dstpitch += bltwidth;
  148:     srcpitch += bltwidth;
  149:     for (y = 0; y < bltheight; y++) {
  150:         for (x = 0; x < bltwidth; x+=2) {
  151:             p1 = *(dst-1);
  152:             p2 = *dst;
  153:             ROP_OP(p1, *(src-1));
  154:             ROP_OP(p2, *src);
  155:             if ((p1 != s->gr[0x34]) || (p2 != s->gr[0x35])) {
  156:                 *(dst-1) = p1;
  157:                 *dst = p2;
  158:             }
  159:             dst-=2;
  160:             src-=2;
  161:         }
  162:         dst += dstpitch;
  163:         src += srcpitch;
  164:     }
  165: }
  166: 
  167: #define DEPTH 8
  168: #include "cirrus_vga_rop2.h"
  169: 
  170: #define DEPTH 16
  171: #include "cirrus_vga_rop2.h"
  172: 
  173: #define DEPTH 24
  174: #include "cirrus_vga_rop2.h"
  175: 
  176: #define DEPTH 32
  177: #include "cirrus_vga_rop2.h"
  178: 
  179: #undef ROP_NAME
  180: #undef ROP_OP