arch/.unmaintained/hidd/unused_planar_funcs.c

   1 /*
   2     Copyright © 1995-2001, The AROS Development Team. All rights reserved.
   3     $Id$
   4 */
   5
   6 static VOID blttemplate_amiga(PLANEPTR source, LONG x_src, LONG modulo, struct BitMap *dest
   7         , LONG x_dest, LONG y_dest, ULONG xsize, ULONG ysize, struct RastPort *rp, struct GfxBase *GfxBase)
   8 {
   9     UBYTE *srcptr;
  10     UBYTE dest_depth = GetBitMapAttr(dest, BMA_DEPTH);
  11     UWORD drmd = GetDrMd(rp);
  12     UBYTE apen = GetAPen(rp);
  13     UBYTE bpen = GetBPen(rp);
  14     LONG x, y;
  15
  16     /* Find the exact startbyte. x_src is max 15 */
  17     srcptr = ((UBYTE *)source) + XCOORD_TO_BYTEIDX(x_src);
  18
  19     /* Find the exact startbit */
  20     x_src &= 0x07;
  21 /*
  22 kprintf("DRMD: %d, APEN: %d, BPEN: %d\n", drmd, apen, bpen);
  23 */
  24     for (y = 0; y < ysize; y ++)
  25     {
  26         UBYTE *byteptr = srcptr;
  27         for (x = 0; x < xsize; x ++)
  28         {
  29             UBYTE pen;
  30             UBYTE mask = XCOORD_TO_MASK( x + x_src );
  31
  32             BOOL is_set = ((*byteptr & mask) ? TRUE : FALSE);
  33             BOOL set_pixel = FALSE;
  34
  35 /*if (is_set)
  36 kprintf("X");
  37 else
  38 kprintf("0");
  39 */
  40             if (drmd & INVERSVID)
  41             {
  42                 is_set = ((is_set == TRUE) ? FALSE : TRUE);
  43             }
  44
  45             if (drmd & JAM2)
  46             {
  47                 /* Use apen if pixel is et, bpen otherwise */
  48                 if (is_set)
  49                     pen = apen;
  50                 else
  51                     pen = bpen;
  52
  53                 set_pixel = TRUE;
  54
  55             }
  56             else if (drmd & COMPLEMENT)
  57             {
  58
  59                 pen = getbitmappixel(dest
  60                         , x + x_dest
  61                         , y + y_dest
  62                         , dest_depth
  63                         , 0xFF
  64                 );
  65
  66                 pen = ~pen;
  67
  68
  69             }
  70             else /* JAM 1 */
  71             {
  72                 /* Only use apen if pixel is set */
  73                 if (is_set)
  74                 {
  75                     pen = apen;
  76                     set_pixel = TRUE;
  77                 }
  78
  79             }
  80             if (set_pixel)
  81             {
  82 /* kprintf("X");
  83 */              setbitmappixel(dest
  84                         , x + x_dest
  85                         , y + y_dest
  86                         , pen
  87                         , dest_depth, 0xFF
  88                 );
  89             }
  90 /* else
  91 kprintf("0");
  92 */
  93             /* Last pixel in this byte ? */
  94             if (((x + x_src) & 0x07) == 0x07)
  95                 byteptr ++;
  96
  97         }
  98 /* kprintf("\n");
  99 */      srcptr += modulo;
 100     }
 101     return;
 102 }
 103
 104
 105
 106
 107 static VOID bltpattern_amiga(struct pattern_info *pi
 108                 , struct BitMap *dest_bm
 109                 , LONG x_src, LONG y_src        /* offset into layer */
 110                 , LONG x_dest, LONG y_dest      /* offset into bitmap */
 111                 , ULONG xsize, LONG ysize
 112                 , struct GfxBase *GfxBase
 113 )
 114 {
 115
 116     /* x_src, y_src is the coordinates int the layer. */
 117     LONG y;
 118     struct RastPort *rp = pi->rp;
 119     ULONG apen = GetAPen(rp);
 120     ULONG bpen = GetBPen(rp);
 121
 122     UBYTE *apt = (UBYTE *)rp->AreaPtrn;
 123
 124     UBYTE dest_depth = GetBitMapAttr(dest_bm, BMA_DEPTH);
 125
 126     for (y = 0; y < ysize; y ++)
 127     {
 128         LONG x;
 129
 130         for (x = 0; x < xsize; x ++)
 131         {
 132             ULONG set_pixel;
 133             ULONG pixval;
 134
 135
 136             /* Mask supplied ? */
 137             if (pi->mask)
 138             {
 139                 ULONG idx, mask;
 140                 idx = COORD_TO_BYTEIDX(x + pi->mask_xmin, y + pi->mask_ymin, pi->mask_bpr);
 141                 mask = XCOORD_TO_MASK(x + pi->mask_xmin);
 142
 143                 set_pixel = pi->mask[idx] & mask;
 144
 145             }
 146             else
 147                 set_pixel = 1UL;
 148
 149
 150             if (set_pixel)
 151             {
 152
 153
 154                 if (apt)
 155                 {
 156
 157                    set_pixel = pattern_pen(rp, x + x_src, y + y_src, apen, bpen, &pixval, GfxBase);
 158                    if (set_pixel)
 159                    {
 160                         setbitmappixel(dest_bm, x + x_dest, y + y_dest, pixval, dest_depth, 0xFF);
 161                    }
 162
 163                 }
 164
 165             } /* if (pixel should be set */
 166
 167
 168         } /* for (each column) */
 169
 170     } /* for (each row) */
 171
 172     return;
 173
 174 }
 175 static VOID bltmask_amiga(struct bltmask_info *bmi
 176         , LONG x_src, LONG y_src
 177         , struct BitMap *destbm
 178         , LONG x_dest, LONG y_dest
 179         , ULONG xsize, ULONG ysize
 180         , ULONG minterm )
 181 {
 182     /* x_src, y_src is the coordinates int the layer. */
 183     LONG y;
 184     UBYTE src_depth, dest_depth;
 185
 186
 187     EnterFunc(bug("bltmask_amiga(%p, %d, %d, %d, %d, %d, %d, %p)\n"
 188                         , bmi, x_src, y_src, x_dest, y_dest, xsize, ysize));
 189
 190     src_depth  = GetBitMapAttr(bmi->srcbm, BMA_DEPTH);
 191     dest_depth = GetBitMapAttr(destbm,     BMA_DEPTH);
 192
 193
 194     for (y = 0; y < ysize; y ++)
 195     {
 196         LONG x;
 197
 198         for (x = 0; x < xsize; x ++)
 199         {
 200             ULONG set_pixel;
 201
 202             ULONG idx, mask;
 203             idx = COORD_TO_BYTEIDX(x + bmi->mask_xmin, y + bmi->mask_ymin, bmi->mask_bpr);
 204             mask = XCOORD_TO_MASK(x + bmi->mask_xmin);
 205
 206             set_pixel = bmi->mask[idx] & mask;
 207
 208             if (set_pixel)
 209             {
 210                 ULONG srcpen, destpen, pixval;
 211                 srcpen = getbitmappixel(bmi->srcbm
 212                         , x + x_src
 213                         , y + y_src
 214                         , src_depth
 215                         , 0xFF
 216                 );
 217
 218 /* Could optimize plain copy (0x00C0) here. (does not nead to get dest)
 219  and clear (0x0000) (needs neither src or dest)*/
 220
 221                 destpen = getbitmappixel(destbm
 222                         , x + x_dest
 223                         , y + y_dest
 224                         , dest_depth
 225                         , 0xFF
 226                 );
 227
 228                 APPLY_MINTERM(pixval, srcpen, destpen, minterm);
 229                 setbitmappixel(destbm
 230                         , x + x_dest
 231                         , y + y_dest
 232                         , pixval
 233                         , dest_depth
 234                         , 0xFF
 235                 );
 236
 237             }
 238
 239
 240         } /* for (each column) */
 241
 242     } /* for (each row) */
 243
 244     ReturnVoid("bltmask_amiga");
 245
 246 }
 247
 248 static VOID hidd2amiga_fast(struct BitMap *hidd_bm
 249         , LONG x_src , LONG y_src
 250         , APTR dest_info
 251         , LONG x_dest, LONG y_dest
 252         , ULONG xsize, ULONG ysize
 253         , VOID (*putbuf_hook)()
 254 )
 255 {
 256
 257     ULONG tocopy_w, tocopy_h;
 258
 259     LONG pixels_left_to_process = xsize * ysize;
 260     ULONG current_x, current_y, next_x, next_y;
 261
 262 #warning Src bitmap migh be user initialized so we should not use HIDD_BM_PIXTAB() below
 263     HIDDT_PixelLUT pixlut = { AROS_PALETTE_SIZE, HIDD_BM_PIXTAB(hidd_bm) };
 264
 265     Object *bm_obj;
 266
 267     next_x = 0;
 268     next_y = 0;
 269
 270     bm_obj = OBTAIN_HIDD_BM(hidd_bm);
 271     if (NULL == bm_obj)
 272         return;
 273
 274 LOCK_PIXBUF
 275
 276     while (pixels_left_to_process)
 277     {
 278
 279         current_x = next_x;
 280         current_y = next_y;
 281
 282         if (NUMLUTPIX < xsize)
 283         {
 284            /* buffer cant hold a single horizontal line, and must
 285               divide each line into copies */
 286             tocopy_w = xsize - current_x;
 287             if (tocopy_w > NUMLUTPIX)
 288             {
 289                 /* Not quite finished with current horizontal pixel line */
 290                 tocopy_w = NUMLUTPIX;
 291                 next_x += NUMLUTPIX;
 292             }
 293             else
 294             {   /* Start at a new line */
 295
 296                 next_x = 0;
 297                 next_y ++;
 298             }
 299             tocopy_h = 1;
 300
 301         }
 302         else
 303         {
 304             tocopy_h = MIN(NUMLUTPIX / xsize, ysize - current_y);
 305             tocopy_w = xsize;
 306
 307             next_x = 0;
 308             next_y += tocopy_h;
 309
 310         }
 311
 312
 313         /* Get some more pixels from the HIDD */
 314         HIDD_BM_GetImageLUT(bm_obj
 315                 , (UBYTE *)pixel_buf
 316                 , tocopy_w
 317                 , x_src + current_x
 318                 , y_src + current_y
 319                 , tocopy_w, tocopy_h
 320                 , &pixlut);
 321
 322
 323         /*  Write pixels to the destination */
 324         putbuf_hook(dest_info
 325                 , current_x + x_src
 326                 , current_y + y_src
 327                 , current_x + x_dest
 328                 , current_y + y_dest
 329                 , tocopy_w, tocopy_h
 330                 , (UBYTE *)pixel_buf
 331                 , bm_obj
 332                 , IS_HIDD_BM(hidd_bm) ? HIDD_BM_PIXTAB(hidd_bm) : NULL
 333         );
 334
 335         pixels_left_to_process -= (tocopy_w * tocopy_h);
 336
 337     }
 338
 339 ULOCK_PIXBUF
 340
 341     RELEASE_HIDD_BM(bm_obj, hidd_bm);
 342
 343     return;
 344
 345 }
 346
 347
 348 struct blit_info
 349 {
 350     struct BitMap *bitmap;
 351     ULONG minterm;
 352     ULONG planemask;
 353     UBYTE bmdepth;
 354     ULONG bmwidth;
 355
 356 };
 357
 358 #define BI(x) ((struct blit_info *)x)
 359 static VOID bitmap_to_buf(APTR src_info
 360         , LONG x_src, LONG y_src
 361         , LONG x_dest, LONG y_dest
 362         , LONG width, LONG height
 363         , ULONG *bufptr
 364         , Object *dest_bm
 365         , HIDDT_Pixel *coltab
 366 ) /* destination HIDD bitmap */
 367 {
 368
 369     LONG y;
 370
 371     /* Fill buffer with pixels from bitmap */
 372     for (y = 0; y < height; y ++)
 373     {
 374         LONG x;
 375
 376         for (x = 0; x < width; x ++)
 377         {
 378             UBYTE pen;
 379
 380             pen = getbitmappixel(BI(src_info)->bitmap
 381                 , x + x_src
 382                 , y + y_src
 383                 , BI(src_info)->bmdepth
 384                 , BI(src_info)->planemask);
 385
 386
 387
 388             *bufptr ++ = (coltab != NULL) ? coltab[pen] : pen;
 389 //          kprintf("(%d, %d) pen=%d buf=%d\n", x, y, pen, coltab[pen]);
 390
 391
 392         }
 393
 394     }
 395
 396 }
 397
 398
 399 static VOID buf_to_bitmap(APTR dest_info
 400         , LONG x_src, LONG y_src
 401         , LONG x_dest, LONG y_dest
 402         , ULONG width, ULONG height
 403         , UBYTE *bufptr
 404         , Object *src_bm
 405         , HIDDT_Pixel *coltab
 406 )
 407 {
 408
 409     if (BI(dest_info)->minterm == 0x00C0)
 410     {
 411         LONG y;
 412         for (y = 0; y < height; y ++)
 413         {
 414             LONG x;
 415             for (x = 0; x < width; x ++)
 416             {
 417                 setbitmappixel(BI(dest_info)->bitmap
 418                         , x + x_dest
 419                         , y + y_dest
 420                         , *bufptr ++, BI(dest_info)->bmdepth, BI(dest_info)->planemask
 421                 );
 422
 423
 424             }
 425
 426         }
 427
 428     }
 429     else
 430     {
 431         LONG y;
 432
 433         for (y = 0; y < height; y ++)
 434         {
 435             LONG x;
 436
 437             for (x = 0; x < width; x ++)
 438             {
 439                 ULONG src = *bufptr ++ , dest = 0;
 440                 ULONG minterm = BI(dest_info)->minterm;
 441
 442                 /* Set the pixel using correct minterm */
 443
 444                 dest = getbitmappixel(BI(dest_info)->bitmap
 445                         , x + x_dest
 446                         , y + y_dest
 447                         , BI(dest_info)->bmdepth
 448                         , BI(dest_info)->planemask
 449                 );
 450
 451 #warning Do reverse coltab lookup
 452                 if (minterm & 0x0010) dest  = ~src & ~dest;
 453                 if (minterm & 0x0020) dest |= ~src & dest;
 454                 if (minterm & 0x0040) dest |=  src & ~dest;
 455                 if (minterm & 0x0080) dest |= src & dest;
 456
 457                 setbitmappixel(BI(dest_info)->bitmap
 458                         , x + x_dest
 459                         , y + y_dest
 460                         , dest, BI(dest_info)->bmdepth
 461                         , BI(dest_info)->planemask
 462                 );
 463
 464             }
 465
 466         }
 467
 468     }
 469     return;
 470
 471 }
 472
 473
 474 static VOID setbitmapfast(struct BitMap *bm, LONG x_start, LONG y_start, LONG xsize, LONG ysize, ULONG pen);
 475
 476
 477
 478 static VOID clipagainstbitmap(struct BitMap *bm, LONG *x1, LONG *y1, LONG *x2, LONG *y2, struct GfxBase *GfxBase)
 479 {
 480     ULONG width  = GetBitMapAttr(bm, BMA_WIDTH);
 481     ULONG height = GetBitMapAttr(bm, BMA_HEIGHT);
 482
 483     /* Clip against bitmap bounds  */
 484
 485     if (*x1 < 0)  *x1 = 0;
 486     if (*y1 < 0)  *y1 = 0;
 487
 488     if (*x2 >= width)  *x2 = width  - 1;
 489     if (*y2 >= height) *y2 = height - 1;
 490
 491     return;
 492 }
 493
 494
 495 static VOID setbitmappixel(struct BitMap *bm
 496         , LONG x, LONG y
 497         , ULONG pen
 498         , UBYTE depth
 499         , UBYTE plane_mask)
 500 {
 501     UBYTE i;
 502     ULONG idx;
 503     UBYTE mask, clr_mask;
 504     ULONG penmask;
 505
 506     idx = COORD_TO_BYTEIDX(x, y, bm->BytesPerRow);
 507
 508     mask = XCOORD_TO_MASK( x );
 509     clr_mask = ~mask;
 510
 511     penmask = 1;
 512     for (i = 0; i < depth; i ++)
 513     {
 514
 515         if ((1L << i) & plane_mask)
 516         {
 517             UBYTE *plane = bm->Planes[i];
 518
 519             if ((plane != NULL) && (plane != (PLANEPTR)-1))
 520             {
 521                 if ((penmask & pen) != 0)
 522                     plane[idx] |=  mask;
 523                 else
 524                     plane[idx] &=  clr_mask;
 525             }
 526
 527         }
 528         penmask <<= 1;
 529
 530     }
 531     return;
 532 }
 533
 534
 535 enum { SB_SINGLEMASK, SB_PREPOSTMASK, SB_FULL };
 536 static VOID setbitmapfast(struct BitMap *bm, LONG x_start, LONG y_start, LONG xsize, LONG ysize, ULONG pen)
 537 {
 538     LONG num_whole;
 539     UBYTE sb_type;
 540
 541     UBYTE plane;
 542     UBYTE pre_pixels_to_set,
 543           post_pixels_to_set,
 544           pre_and_post; /* number pixels to clear in pre and post byte */
 545
 546     UBYTE prebyte_mask, postbyte_mask;
 547
 548 /*    kprintf("x_start: %d, y_start: %d, xsize: %d, ysize: %d, pen: %d\n",
 549         x_start, y_start, xsize, ysize, pen);
 550 */
 551
 552     pre_pixels_to_set  = (7 - (x_start & 0x07)) + 1;
 553     post_pixels_to_set = ((x_start + xsize - 1) & 0x07) + 1;
 554
 555
 556     pre_and_post = pre_pixels_to_set + post_pixels_to_set;
 557
 558     if (pre_and_post > xsize)
 559     {
 560         UBYTE start_bit, stop_bit;
 561         /* Check whether the pixels are kept within a byte */
 562         sb_type = SB_SINGLEMASK;
 563         pre_pixels_to_set  = MIN(pre_pixels_to_set,  xsize);
 564
 565         /* Mask out the needed bits */
 566         start_bit =  7 - (x_start & 0x07) + 1;
 567         stop_bit = 7 - ((x_start + xsize - 1) & 0x07);
 568
 569 /* kprintf("start_bit: %d, stop_bit: %d\n", start_bit, stop_bit);
 570 */
 571         prebyte_mask = ((1L << start_bit) - 1) - ((1L << stop_bit) - 1) ;
 572 /* kprintf("prebyte_mask: %d\n", prebyte_mask);
 573
 574 kprintf("SB_SINGLE\n");
 575 */
 576     }
 577     else if (pre_and_post == xsize)
 578     {
 579         /* We have bytes within to neighbour pixels */
 580         sb_type = SB_PREPOSTMASK;
 581         prebyte_mask  = 0xFF >> (8 - pre_pixels_to_set);
 582         postbyte_mask = 0xFF << (8 - post_pixels_to_set);
 583
 584 /* kprintf("SB_PREPOSTMASK\n");
 585 */
 586     }
 587     else
 588     {
 589
 590         /* Say we want to clear two pixels in last byte. We want the mask
 591         MSB 00000011 LSB
 592         */
 593         sb_type = SB_FULL;
 594         prebyte_mask = 0xFF >> (8 - pre_pixels_to_set);
 595
 596         /* Say we want to set two pixels in last byte. We want the mask
 597         MSB 11000000 LSB
 598         */
 599         postbyte_mask = 0xFF << (8 - post_pixels_to_set);
 600
 601                 /* We have at least one whole byte of pixels */
 602         num_whole = xsize - pre_pixels_to_set - post_pixels_to_set;
 603         num_whole >>= 3; /* number of bytes */
 604
 605 /* kprintf("SB_FULL\n");
 606 */
 607     }
 608
 609 /*
 610 kprintf("pre_pixels_to_set: %d, post_pixels_to_set: %d, numwhole: %d\n"
 611         , pre_pixels_to_set, post_pixels_to_set, num_whole);
 612
 613 kprintf("prebyte_mask: %d, postbyte_mask: %d, numwhole: %d\n", prebyte_mask, postbyte_mask, num_whole);
 614 */
 615     for (plane = 0; plane < GetBitMapAttr(bm, BMA_DEPTH); plane ++)
 616     {
 617
 618         LONG y;
 619         UBYTE pixvals;
 620         UBYTE prepixels_set, prepixels_clr;
 621         UBYTE postpixels_set, postpixels_clr;
 622         UBYTE *curbyte = ((UBYTE *)bm->Planes[plane]) + COORD_TO_BYTEIDX(x_start, y_start, bm->BytesPerRow);
 623
 624
 625         /* Set or clear current bit of pixval ? */
 626         if (pen & (1L << plane))
 627             pixvals = 0xFF;
 628         else
 629             pixvals = 0x00;
 630
 631         /* Set the pre and postpixels */
 632         switch (sb_type)
 633         {
 634             case SB_FULL:
 635                 prepixels_set  = (pixvals & prebyte_mask);
 636                 postpixels_set = (pixvals & postbyte_mask);
 637
 638
 639                 prepixels_clr  = (pixvals & prebyte_mask)  | (~prebyte_mask);
 640                 postpixels_clr = (pixvals & postbyte_mask) | (~postbyte_mask);
 641
 642                 for (y = 0; y < ysize; y ++)
 643                 {
 644                     LONG x;
 645                     UBYTE *ptr = curbyte;
 646
 647                     *ptr |= prepixels_set;
 648                     *ptr ++ &= prepixels_clr;
 649
 650                     for (x = 0; x < num_whole; x ++)
 651                     {
 652                         *ptr ++ = pixvals;
 653                     }
 654                     /* Clear the last nonwhole byte */
 655                     *ptr |= postpixels_set;
 656                     *ptr ++ &= postpixels_clr;
 657
 658                     /* Go to next line */
 659                     curbyte += bm->BytesPerRow;
 660                 }
 661                 break;
 662
 663             case SB_PREPOSTMASK:
 664
 665                 prepixels_set  = (pixvals & prebyte_mask);
 666                 postpixels_set = (pixvals & postbyte_mask);
 667
 668
 669                 prepixels_clr  = (pixvals & prebyte_mask)  | (~prebyte_mask);
 670                 postpixels_clr = (pixvals & postbyte_mask) | (~postbyte_mask);
 671
 672                 for (y = 0; y < ysize; y ++)
 673                 {
 674                     UBYTE *ptr = curbyte;
 675
 676                     *ptr |= prepixels_set;
 677                     *ptr ++ &= prepixels_clr;
 678
 679                     /* Clear the last nonwhole byte */
 680                     *ptr |= postpixels_set;
 681                     *ptr ++ &= postpixels_clr;
 682
 683                     /* Go to next line */
 684                     curbyte += bm->BytesPerRow;
 685                 }
 686                 break;
 687
 688             case SB_SINGLEMASK:
 689
 690                 prepixels_set  = (pixvals & prebyte_mask);
 691                 prepixels_clr  = (pixvals & prebyte_mask) | (~prebyte_mask);
 692
 693                 for (y = 0; y < ysize; y ++)
 694                 {
 695                     UBYTE *ptr = curbyte;
 696
 697                     *ptr |= prepixels_set;
 698                     *ptr ++ &= prepixels_clr;
 699
 700                     /* Go to next line */
 701                     curbyte += bm->BytesPerRow;
 702                 }
 703                 break;
 704
 705         } /* switch() */
 706     }
 707     return;
 708
 709 }
 710
 711
 712