rom/graphics/bltmaskbitmaprastport.c

   1 /*
   2     Copyright © 1995-2011, The AROS Development Team. All rights reserved.
   3     $Id$
   4
   5     Desc:
   6     Lang: english
   7 */
   8 #include <aros/debug.h>
   9 #include <proto/graphics.h>
  10 #include <proto/oop.h>
  11 #include "graphics_intern.h"
  12 #include "gfxfuncsupport.h"
  13 #include <hardware/blit.h>
  14
  15 struct bltmask_render_data
  16 {
  17     struct render_special_info rsi;
  18     struct BitMap              *srcbm;
  19     OOP_Object                 *srcbm_obj;
  20     OOP_Object                 *srcpf;
  21     HIDDT_ColorModel           src_colmod;
  22     PLANEPTR                   mask;
  23     ULONG                      mask_bpr;
  24     ULONG                      minterm;
  25     BOOL                       samebitmapformat;
  26 };
  27
  28 static ULONG bltmask_render(APTR bltmask_rd, LONG srcx, LONG srcy,
  29                             OOP_Object *dstbm_obj, OOP_Object *dst_gc,
  30                             LONG x1, LONG y1, LONG x2, LONG y2, struct GfxBase *GfxBase);
  31
  32 /*****************************************************************************
  33
  34     NAME */
  35 #include <clib/graphics_protos.h>
  36
  37         AROS_LH10(void, BltMaskBitMapRastPort,
  38
  39 /*  SYNOPSIS */
  40         AROS_LHA(struct BitMap   *, srcBitMap, A0),
  41         AROS_LHA(LONG             , xSrc, D0),
  42         AROS_LHA(LONG             , ySrc, D1),
  43         AROS_LHA(struct RastPort *, destRP, A1),
  44         AROS_LHA(LONG             , xDest, D2),
  45         AROS_LHA(LONG             , yDest, D3),
  46         AROS_LHA(LONG             , xSize, D4),
  47         AROS_LHA(LONG             , ySize, D5),
  48         AROS_LHA(ULONG            , minterm, D6),
  49         AROS_LHA(PLANEPTR         , bltMask, A2),
  50
  51 /*  LOCATION */
  52         struct GfxBase *, GfxBase, 106, Graphics)
  53
  54 /*  FUNCTION
  55         Copies a part of a bitmap to another bitmap with using a mask.
  56
  57     INPUTS
  58         srcBitMap - Copy from this bitmap.
  59         xSrc, ySrc - This is the upper left corner of the area to copy.
  60         destRP - Destination RastPort.
  61         xDest, yDest - Upper left corner where to place the copy
  62         xSize, ySize - The size of the area to copy
  63         minterm - How to copy. See BltBitMap() for an explanation.
  64         bltMask - The mask bitplane must be of the same size as the source bitmap.
  65
  66     RESULT
  67         TRUE.
  68
  69     NOTES
  70
  71     EXAMPLE
  72
  73     BUGS
  74
  75     SEE ALSO
  76         ClipBlit()
  77
  78     INPUTS
  79
  80     RESULT
  81
  82     NOTES
  83
  84     INTERNALS
  85
  86     HISTORY
  87         27-11-96    digulla automatically created from
  88                             graphics_lib.fd and clib/graphics_protos.h
  89
  90 *****************************************************************************/
  91 {
  92     AROS_LIBFUNC_INIT
  93
  94     struct bltmask_render_data  brd;
  95     struct Rectangle            rr;
  96     HIDDT_DrawMode              old_drmd;
  97     OOP_Object                  *gc;
  98     Point                       src;
  99
 100     struct TagItem gc_tags[] =
 101     {
 102         { aHidd_GC_DrawMode , 0UL },
 103         { TAG_DONE                }
 104     };
 105
 106     EnterFunc(bug("BltMaskBitMapRastPort(%d %d %d, %d, %d, %d)\n"
 107         , xSrc, ySrc, xDest, yDest, xSize, ySize));
 108
 109     FIX_GFXCOORD(xSrc);
 110     FIX_GFXCOORD(ySrc);
 111     FIX_GFXCOORD(xDest);
 112     FIX_GFXCOORD(yDest);
 113
 114     if ((xSize < 1) || (ySize < 1)) return;
 115
 116     if (!OBTAIN_DRIVERDATA(destRP, GfxBase))
 117         return;
 118
 119     brd.minterm = minterm;
 120     brd.srcbm_obj = OBTAIN_HIDD_BM(srcBitMap);
 121     if (NULL == brd.srcbm_obj)
 122     {
 123         RELEASE_DRIVERDATA(destRP, GfxBase);
 124         return;
 125     }
 126
 127     brd.srcbm = srcBitMap;
 128     brd.mask  = bltMask;
 129
 130     /* The mask has always the same size as the source bitmap */
 131     brd.mask_bpr = 2 * WIDTH_TO_WORDS(GetBitMapAttr(srcBitMap, BMA_WIDTH));
 132
 133     OOP_GetAttr(brd.srcbm_obj, aHidd_BitMap_PixFmt, (IPTR *)&brd.srcpf);
 134     {
 135         IPTR attr;
 136
 137         OOP_GetAttr(brd.srcpf, aHidd_PixFmt_ColorModel, &attr);
 138         brd.src_colmod = (HIDDT_ColorModel)attr;
 139     }
 140
 141     gc = GetDriverData(destRP)->dd_GC;
 142     OOP_GetAttr(gc, aHidd_GC_DrawMode, &old_drmd);
 143
 144     gc_tags[0].ti_Data = vHidd_GC_DrawMode_Copy;
 145     OOP_SetAttrs(gc, gc_tags);
 146
 147     rr.MinX = xDest;
 148     rr.MinY = yDest;
 149     rr.MaxX = xDest + xSize - 1;
 150     rr.MaxY = yDest + ySize - 1;
 151
 152     src.x = xSrc;
 153     src.y = ySrc;
 154
 155     do_render_func(destRP, &src, &rr, bltmask_render, &brd, TRUE, TRUE, GfxBase);
 156
 157     RELEASE_HIDD_BM(brd.srcbm_obj, srcBitMap);
 158
 159     gc_tags[0].ti_Data = old_drmd;
 160     OOP_SetAttrs(gc, gc_tags);
 161
 162     RELEASE_DRIVERDATA(destRP, GfxBase);
 163
 164     ReturnVoid("BltBitMapRastPort");
 165
 166     AROS_LIBFUNC_EXIT
 167
 168 } /* BltMaskBitMapRastPort */
 169
 170 /****************************************************************************************/
 171
 172 static ULONG bltmask_render(APTR bltmask_rd, LONG srcx, LONG srcy,
 173                             OOP_Object *dstbm_obj, OOP_Object *dst_gc,
 174                             LONG x1, LONG y1, LONG x2, LONG y2, struct GfxBase *GfxBase)
 175 {
 176     struct bltmask_render_data  *brd;
 177     OOP_Object                  *dest_pf;
 178     HIDDT_ColorModel            dest_colmod;
 179     HIDDT_Pixel                 *pixtab = NULL;
 180     ULONG                       x, y, width, height;
 181     LONG                        lines_done, lines_per_step, doing_lines;
 182     BOOL                        pal_to_true = FALSE;
 183     ULONG                       pixfmt = vHidd_StdPixFmt_Native32;
 184
 185     width  = x2 - x1 + 1;
 186     height = y2 - y1 + 1;
 187
 188     OOP_GetAttr(dstbm_obj, aHidd_BitMap_PixFmt, (IPTR *)&dest_pf);
 189     {
 190         IPTR attr;
 191
 192         OOP_GetAttr(dest_pf, aHidd_PixFmt_ColorModel, &attr);
 193         dest_colmod = (HIDDT_ColorModel)attr;
 194     }
 195
 196     brd = (struct bltmask_render_data *)bltmask_rd;
 197     if ((brd->src_colmod == vHidd_ColorModel_Palette) && (dest_colmod == vHidd_ColorModel_Palette))
 198     {
 199     }
 200     else if ((brd->src_colmod == vHidd_ColorModel_Palette) && (dest_colmod == vHidd_ColorModel_TrueColor))
 201     {
 202         pixtab = IS_HIDD_BM(brd->srcbm) ? HIDD_BM_PIXTAB(brd->srcbm) : NULL;
 203         if (!pixtab) pixtab = IS_HIDD_BM(brd->rsi.curbm) ? HIDD_BM_PIXTAB(brd->rsi.curbm) : NULL;
 204
 205         if (!pixtab)
 206         {
 207             D(bug("BltMaskBitMapRastPort could not retrieve pixel table for blit from palette to truecolor bitmap"));
 208             return width * height;
 209         }
 210
 211         pal_to_true = TRUE;
 212     }
 213     else if ((brd->src_colmod == vHidd_ColorModel_TrueColor) && (dest_colmod == vHidd_ColorModel_TrueColor))
 214     {
 215         if (brd->srcpf != dest_pf)
 216         {
 217             pixfmt = vHidd_StdPixFmt_ARGB32;
 218         }
 219     }
 220     else if ((brd->src_colmod == vHidd_ColorModel_TrueColor) && (dest_colmod == vHidd_ColorModel_Palette))
 221     {
 222         D(bug("BltMaskBitMapRastPort from truecolor bitmap to palette bitmap not supported!"));
 223         return width * height;
 224     }
 225
 226     lines_per_step = (NUMPIX / (width * 2 * sizeof(HIDDT_Pixel)));
 227     if (lines_per_step)
 228     {
 229         UBYTE *srcbuf, *destbuf;
 230
 231         LOCK_PIXBUF
 232
 233         srcbuf = (UBYTE *)PrivGBase(GfxBase)->pixel_buf;
 234         destbuf = srcbuf;
 235         destbuf += lines_per_step * width * sizeof(HIDDT_Pixel);
 236
 237         for(lines_done = 0; lines_done != height; lines_done += doing_lines)
 238         {
 239             HIDDT_Pixel *srcpixelbuf;
 240             HIDDT_Pixel *destpixelbuf;
 241             UBYTE       *mask;
 242
 243             doing_lines = lines_per_step;
 244             if (lines_done + doing_lines > height) doing_lines = height - lines_done;
 245
 246             HIDD_BM_GetImage(brd->srcbm_obj,
 247                              srcbuf,
 248                              width * sizeof(HIDDT_Pixel),
 249                              srcx, srcy + lines_done,
 250                              width, doing_lines,
 251                              pixfmt);
 252
 253             HIDD_BM_GetImage(dstbm_obj,
 254                              destbuf,
 255                              width * sizeof(HIDDT_Pixel),
 256                              x1, y1 + lines_done,
 257                              width, doing_lines,
 258                              pixfmt);
 259
 260             mask = &brd->mask[COORD_TO_BYTEIDX(0, srcy + lines_done, brd->mask_bpr)];
 261
 262             srcpixelbuf  = (HIDDT_Pixel *)srcbuf;
 263             destpixelbuf = (HIDDT_Pixel *)destbuf;
 264
 265             switch(brd->minterm)
 266             {
 267                 case (ABC|ABNC|ANBC): /* (ABC|ABNC|ANBC) if copy source and blit thru mask */
 268                 case 0xC0: /* compatibility with AOS3 */
 269                     if (pal_to_true)
 270                     {
 271                         for(y = 0; y < doing_lines; y++)
 272                         {
 273                             for(x = 0; x < width; x++)
 274                             {
 275                                 if (mask[XCOORD_TO_BYTEIDX(srcx + x)] & XCOORD_TO_MASK(srcx + x))
 276                                 {
 277                                     *destpixelbuf = pixtab[*srcpixelbuf];
 278                                 }
 279                                 srcpixelbuf++;
 280                                 destpixelbuf++;
 281                             }
 282                             mask += brd->mask_bpr;
 283                         }
 284                     }
 285                     else
 286                     {
 287                         for(y = 0; y < doing_lines; y++)
 288                         {
 289                             for(x = 0; x < width; x++)
 290                             {
 291                                 if (mask[XCOORD_TO_BYTEIDX(srcx + x)] & XCOORD_TO_MASK(srcx + x))
 292                                 {
 293                                     *destpixelbuf = *srcpixelbuf;
 294                                 }
 295                                 srcpixelbuf++;
 296                                 destpixelbuf++;
 297                             }
 298                             mask += brd->mask_bpr;
 299                         }
 300                     }
 301                     break;
 302
 303                 case ANBC: /* (ANBC) if invert source and blit thru mask */
 304                     D(bug("BltMaskBitMapRastPort does not support ANBC minterm yet"));
 305                     break;
 306
 307                 default:
 308                     D(bug("BltMaskBitMapRastPort: minterm 0x%x not handled.\n", brd->minterm));
 309                     break;
 310             } /* switch(brd->minterm) */
 311
 312             HIDD_BM_PutImage(dstbm_obj,
 313                              dst_gc,
 314                              destbuf,
 315                              width * sizeof(HIDDT_Pixel),
 316                              x1, y1 + lines_done,
 317                              width, doing_lines,
 318                              pixfmt);
 319
 320         } /* for(lines_done = 0; lines_done != height; lines_done += doing_lines) */
 321
 322         ULOCK_PIXBUF
 323
 324     } /* if (lines_per_step) */
 325     else
 326     {
 327         /* urk :-( pixelbuffer too small to hold two lines) */
 328
 329         D(bug("BltMaskBitMapRastPort found pixelbuffer to be too small"));
 330     }
 331
 332     return width * height;
 333 }
 334
 335 /****************************************************************************************/