rom/hidds/graphics/gfx_planarbitmapclass.c

   1 /*
   2     Copyright © 1995-2017, The AROS Development Team. All rights reserved.
   3     $Id$
   4
   5     Desc: Gfx Hidd planar bitmap class implementation.
   6     Lang: english
   7 */
   8
   9 /****************************************************************************************/
  10
  11 #include "gfx_debug.h"
  12
  13 #include <proto/exec.h>
  14 #include <proto/utility.h>
  15 #include <proto/oop.h>
  16
  17 #include <exec/memory.h>
  18 #include <utility/tagitem.h>
  19 #include <graphics/gfx.h>
  20 #include <oop/oop.h>
  21
  22 #include <hidd/gfx.h>
  23
  24 #include <string.h>
  25
  26 #include "gfx_intern.h"
  27
  28 /*****************************************************************************************
  29
  30     NAME
  31         --background_planarbm--
  32
  33     LOCATION
  34         hidd.gfx.bitmap.planarbm
  35
  36     NOTES
  37         This is a class representing a planar Amiga(tm) bitmap in AROS graphics subsystem.
  38
  39         When you create an object of this class, an associated planar bitmap will be created.
  40         However, it's possible to use this class with pre-existing bitmaps, making them
  41         available to the graphics HIDD subsystem.
  42
  43 *****************************************************************************************/
  44
  45 /*****************************************************************************************
  46
  47     NAME
  48         aoHidd_PlanarBM_AllocPlanes
  49
  50     SYNOPSIS
  51         [I..], BOOL
  52
  53     LOCATION
  54         hidd.gfx.bitmap.planarbm
  55
  56     FUNCTION
  57         Set this attribute to FALSE if you want to create an empty bitmap object containing
  58         no bitmap data. Useful if you want to create an empty object to be associated with
  59         existing bitmap later.
  60
  61     NOTES
  62         This attribute is obsolete. It's equal to supplying aoHidd_PlanarBM_BitMap attribute
  63         with a NULL value.
  64
  65     EXAMPLE
  66
  67     BUGS
  68
  69     SEE ALSO
  70         aoHidd_PlanarBM_BitMap
  71
  72     INTERNALS
  73
  74 *****************************************************************************************/
  75
  76 /*****************************************************************************************
  77
  78     NAME
  79         aoHidd_PlanarBM_BitMap
  80
  81     SYNOPSIS
  82         [ISG], struct BitMap *
  83
  84     LOCATION
  85         hidd.gfx.bitmap.planarbm
  86
  87     FUNCTION
  88         Allows to specify or retrieve a raw planar bitmap structure associated with the object.
  89         Useful for direct access to the bitmap within subclasses, as well as for associating
  90         an object with already existing BitMap structure.
  91
  92         It is valid to pass this attribute with a NULL value. In this case the object becomes
  93         empty and contains no actual bitmap.
  94
  95     NOTES
  96         If the object was created with own bitmap data (with no aoHidd_PlanarBM_BitMap specified
  97         during creation), this data will be deallocated when you set this attribute.
  98
  99         It's up to you to deallocate own bitmaps, set using this attribute. Even if the object
 100         is disposed, it won't deallocate user-supplied bitmap.
 101
 102     EXAMPLE
 103
 104     BUGS
 105
 106     SEE ALSO
 107
 108     INTERNALS
 109
 110 *****************************************************************************************/
 111
 112 OOP_Object *PBM__Root__New(OOP_Class *cl, OOP_Object *o, struct pRoot_New *msg)
 113 {
 114     struct Library *UtilityBase = CSD(cl)->cs_UtilityBase;
 115     struct Library *OOPBase = CSD(cl)->cs_OOPBase;
 116     IPTR height, bytesperrow;
 117     UBYTE depth;
 118     IPTR displayable = FALSE;
 119     BOOL ok = FALSE;
 120     struct planarbm_data *data;
 121     struct TagItem *tag;
 122
 123     o = (OOP_Object *)OOP_DoSuperMethod(cl, o, &msg->mID);
 124     if (NULL == o)
 125         return NULL;
 126
 127     data = OOP_INST_DATA(cl, o);
 128
 129     /* Check if we want to use existing bitmap */
 130
 131     tag = FindTagItem(aHidd_PlanarBM_BitMap, msg->attrList);
 132     if (tag)
 133     {
 134         /* It's not our own bitmap */
 135         data->planes_alloced = FALSE;
 136         /* Remember the bitmap. It can be NULL here. */
 137         data->bitmap = (struct BitMap *)tag->ti_Data;
 138
 139         /* That's all, we are attached to an existing BitMap */
 140         return o;
 141     }
 142     else
 143     {
 144         /* Check obsolete attribute now */
 145         data->planes_alloced = GetTagData(aHidd_PlanarBM_AllocPlanes, TRUE, msg->attrList);
 146
 147         if (!data->planes_alloced)
 148             return o; /* Late initialization */
 149     }
 150
 151     /* By default we create 1-plane bitmap */
 152     depth = GetTagData(aHidd_BitMap_Depth, 1, msg->attrList);
 153
 154     /* Not late initialization. Get some info on the bitmap */
 155     OOP_GetAttr(o, aHidd_BitMap_Height, &height);
 156     OOP_GetAttr(o, aHidd_BitMap_BytesPerRow, &bytesperrow);
 157     OOP_GetAttr(o, aHidd_BitMap_Displayable, &displayable);
 158
 159     data->bitmap = AllocMem(sizeof(struct BitMap), MEMF_CLEAR);
 160     if (data->bitmap)
 161     {
 162         UBYTE i;
 163
 164         ok = TRUE;
 165
 166         /* We cache some info */
 167         data->bitmap->Rows        = height;
 168         data->bitmap->BytesPerRow = bytesperrow;
 169         data->bitmap->Depth       = depth;
 170         data->bitmap->Flags       = BMF_STANDARD|BMF_MINPLANES; /* CHECKME */
 171         if (displayable)
 172             data->bitmap->Flags |= BMF_DISPLAYABLE;
 173
 174         /* Allocate memory for all the planes. Use chip memory. */
 175         for (i = 0; i < depth; i++)
 176         {
 177             data->bitmap->Planes[i] = AllocMem(height * bytesperrow, MEMF_CHIP | MEMF_CLEAR);
 178
 179             if (NULL == data->bitmap->Planes[i])
 180             {
 181                 ok = FALSE;
 182                 break;
 183             }
 184         }
 185     }
 186
 187     if (!ok)
 188     {
 189         OOP_MethodID dispose_mid;
 190
 191         dispose_mid = OOP_GetMethodID(IID_Root, moRoot_Dispose);
 192         OOP_CoerceMethod(cl, o, (OOP_Msg)&dispose_mid);
 193
 194         o = NULL;
 195     }
 196
 197     return o;
 198 }
 199
 200 /****************************************************************************************/
 201
 202 static void PBM_FreeBitMap(struct planarbm_data *data)
 203 {
 204     if (data->planes_alloced)
 205     {
 206         if (NULL != data->bitmap)
 207         {
 208             UBYTE i;
 209
 210             for (i = 0; i < data->bitmap->Depth; i++)
 211             {
 212                 if (data->bitmap->Planes[i])
 213                 {
 214                     FreeMem(data->bitmap->Planes[i], data->bitmap->Rows * data->bitmap->BytesPerRow);
 215                 }
 216             }
 217             FreeMem(data->bitmap, sizeof(struct BitMap));
 218         }
 219     }
 220 }
 221
 222 VOID PBM__Root__Dispose(OOP_Class *cl, OOP_Object *o, OOP_Msg msg)
 223 {
 224     struct planarbm_data *data = OOP_INST_DATA(cl, o);
 225
 226     PBM_FreeBitMap(data);
 227     OOP_DoSuperMethod(cl, o, msg);
 228 }
 229
 230 /****************************************************************************************/
 231
 232 VOID PBM__Root__Get(OOP_Class *cl, OOP_Object *obj, struct pRoot_Get *msg)
 233 {
 234     struct planarbm_data *data = OOP_INST_DATA(cl, obj);
 235
 236     if (msg->attrID == aHidd_BitMap_Depth)
 237     {
 238         /* Planar bitmaps may have a variable depth. */
 239         *msg->storage = data->bitmap ? data->bitmap->Depth : 0;
 240         return;
 241     }
 242     else if (msg->attrID == aHidd_PlanarBM_BitMap)
 243     {
 244         *msg->storage = (IPTR)data->bitmap;
 245         return;
 246     }
 247
 248     OOP_DoSuperMethod(cl, obj, &msg->mID);
 249 }
 250
 251 /****************************************************************************************/
 252
 253 static BOOL PBM_SetBitMap(OOP_Class *cl, OOP_Object *o, struct BitMap *bm)
 254 {
 255     struct TagItem pftags[] =
 256     {
 257         { aHidd_PixFmt_Depth        , 0UL                       },      /* 0 */
 258         { aHidd_PixFmt_BitsPerPixel , 0UL                       },      /* 1 */
 259         { aHidd_PixFmt_BytesPerPixel, 1UL                       },      /* 2 */
 260         { aHidd_PixFmt_ColorModel   , vHidd_ColorModel_Palette  },      /* 3 */
 261         { aHidd_PixFmt_BitMapType   , vHidd_BitMapType_Planar   },      /* 4 */
 262         { aHidd_PixFmt_CLUTShift    , 0UL                       },      /* 5 */
 263         { aHidd_PixFmt_CLUTMask     , 0x000000FF                },      /* 6 */
 264         { aHidd_PixFmt_RedMask      , 0x00FF0000                },      /* 7 */
 265         { aHidd_PixFmt_GreenMask    , 0x0000FF00                },      /* 8 */
 266         { aHidd_PixFmt_BlueMask     , 0x000000FF                },      /* 9 */
 267         { aHidd_PixFmt_StdPixFmt    , vHidd_StdPixFmt_Plane     },
 268         { TAG_DONE                  , 0UL                       }
 269     };
 270     struct TagItem      bmtags[] =
 271     {
 272         { aHidd_BitMap_Width        , 0 }, /* 0 */
 273         { aHidd_BitMap_Height       , 0 }, /* 1 */
 274         { aHidd_BitMap_BytesPerRow  , 0 }, /* 2 */
 275         { TAG_DONE                  , 0 }
 276     };
 277     struct planarbm_data *data = OOP_INST_DATA(cl, o);
 278     OOP_Object *pf;
 279
 280     /* First we attempt to register a pixelformat */
 281     pftags[0].ti_Data = bm->Depth;      /* PixFmt_Depth */
 282     pftags[1].ti_Data = bm->Depth;      /* PixFmt_BitsPerPixel */
 283
 284     pf = GFXHIDD__Hidd_Gfx__RegisterPixFmt(CSD(cl)->gfxhiddclass, pftags);
 285
 286     if (!pf)
 287     {
 288         /* Fail is pixelformat registration failed */
 289         return FALSE;
 290     }
 291
 292     /* Free old bitmap, if it was ours. */
 293     PBM_FreeBitMap(data);
 294
 295     /* Set the new bitmap. It's not ours. */
 296     data->bitmap = bm;
 297     data->planes_alloced = FALSE;
 298
 299     /* Call private bitmap method to update superclass */
 300     bmtags[0].ti_Data = bm->BytesPerRow * 8;
 301     bmtags[1].ti_Data = bm->Rows;
 302     bmtags[2].ti_Data = bm->BytesPerRow;
 303
 304     BM__Hidd_BitMap__SetBitMapTags(CSD(cl)->bitmapclass, o, bmtags);
 305     BM__Hidd_BitMap__SetPixFmt(CSD(cl)->bitmapclass, o, pf);
 306
 307     return TRUE;
 308 }
 309
 310 VOID PBM__Root__Set(OOP_Class *cl, OOP_Object *obj, struct pRoot_Set *msg)
 311 {
 312     struct Library *UtilityBase = CSD(cl)->cs_UtilityBase;
 313     struct TagItem *tag = FindTagItem(aHidd_PlanarBM_BitMap, msg->attrList);
 314
 315     if (tag)
 316     {
 317         /*
 318          * TODO: We can't check for failure here. However, since we already
 319          * have Depth attribute for the bitmap, may be we shouldn't register
 320          * 8 pixelformats? In this case we are unable to fail.
 321          */
 322         PBM_SetBitMap(cl, obj, (struct BitMap *)tag->ti_Data);
 323     }
 324
 325     OOP_DoSuperMethod(cl, obj, &msg->mID);
 326 }
 327
 328 /****************************************************************************************/
 329
 330 VOID PBM__Hidd_BitMap__PutPixel(OOP_Class *cl, OOP_Object *o,
 331                                 struct pHidd_BitMap_PutPixel *msg)
 332 {
 333     UBYTE                   **plane;
 334     struct planarbm_data    *data;
 335     ULONG                   offset;
 336     UWORD                   mask;
 337     UBYTE                   pixel, notpixel;
 338     UBYTE                   i;
 339
 340     data = OOP_INST_DATA(cl, o);
 341
 342     if (!data->bitmap)
 343         return;
 344
 345     /* bitmap in plane-mode */
 346     plane     = data->bitmap->Planes;
 347     offset    = msg->x / 8 + msg->y * data->bitmap->BytesPerRow;
 348     pixel     = 128 >> (msg->x % 8);
 349     notpixel  = ~pixel;
 350     mask      = 1;
 351
 352     for (i = 0; i < data->bitmap->Depth; i++, mask <<=1, plane ++)
 353     {
 354         if ((*plane != NULL) && (*plane != (UBYTE *)-1))
 355         {
 356             if(msg->pixel & mask)
 357             {
 358                 *(*plane + offset) = *(*plane + offset) | pixel;
 359             }
 360             else
 361             {
 362                 *(*plane + offset) = *(*plane + offset) & notpixel;
 363             }
 364         }
 365     }
 366 }
 367
 368 /****************************************************************************************/
 369
 370 ULONG PBM__Hidd_BitMap__GetPixel(OOP_Class *cl, OOP_Object *o,
 371                                  struct pHidd_BitMap_GetPixel *msg)
 372 {
 373     struct planarbm_data    *data;
 374     UBYTE                   **plane;
 375     ULONG                   offset;
 376     UWORD                   i;
 377     UBYTE                   pixel;
 378     ULONG                   retval;
 379
 380     data = OOP_INST_DATA(cl, o);
 381
 382     if (!data->bitmap)
 383         return 0;
 384
 385     plane     = data->bitmap->Planes;
 386     offset    = msg->x / 8 + msg->y * data->bitmap->BytesPerRow;
 387     pixel     = 128 >> (msg->x % 8);
 388     retval    = 0;
 389
 390     for (i = 0; i < data->bitmap->Depth; i++, plane ++)
 391     {
 392         if (*plane == (UBYTE *)-1)
 393         {
 394             retval = retval | (1 << i);
 395         }
 396         else if (*plane != NULL)
 397         {
 398             if(*(*plane + offset) & pixel)
 399             {
 400                 retval = retval | (1 << i);
 401             }
 402         }
 403     }
 404
 405     return retval;
 406 }
 407
 408 /****************************************************************************************/
 409
 410 /*
 411  * In fact these two routines are implementations of C2P algorighm. The first one takes chunky
 412  * array of 8-bit values, the second one - 32-bit one.
 413  */
 414 static void PBM_PutImage_Native(UBYTE *src, ULONG modulo, struct BitMap *data, UWORD startx, UWORD starty, UWORD width, UWORD height)
 415 {
 416     ULONG planeoffset  = starty * data->BytesPerRow + startx / 8;
 417     UWORD x, y, d;
 418
 419     startx &= 7;
 420
 421     for (y = 0; y < height; y++)
 422     {
 423         UBYTE **plane = data->Planes;
 424
 425         for (d = 0; d < data->Depth; d++)
 426         {
 427             UWORD dmask = 1L << d;
 428             UWORD pmask = 0x80 >> startx;
 429             UBYTE *pl = *plane;
 430
 431             if (pl == (UBYTE *)-1) continue;
 432             if (pl == NULL) continue;
 433
 434             pl += planeoffset;
 435
 436             for (x = 0; x < width; x++)
 437             {
 438                 if (src[x] & dmask)
 439                 {
 440                     *pl |= pmask;
 441                 }
 442                 else
 443                 {
 444                     *pl &= ~pmask;
 445                 }
 446
 447                 if (pmask == 0x1)
 448                 {
 449                     pmask = 0x80;
 450                     pl++;
 451                 }
 452                 else
 453                 {
 454                     pmask >>= 1;
 455                 }
 456             } /* for (x = 0; x < msg->width; x++) */
 457
 458             plane++;
 459
 460         } /* for (d = 0; d < data->depth; d++) */
 461
 462         src         += modulo;
 463         planeoffset += data->BytesPerRow;
 464     } /* for (y = 0; y < msg->height; y++) */
 465 }
 466
 467 static void PBM_PutImage_Native32(HIDDT_Pixel *src, ULONG modulo, struct BitMap *data, UWORD startx, UWORD starty, UWORD width, UWORD height)
 468 {
 469     ULONG planeoffset  = starty * data->BytesPerRow + startx / 8;
 470     UWORD x, y, d;
 471
 472     startx &= 7;
 473
 474     for (y = 0; y < height; y++)
 475     {
 476         UBYTE **plane = data->Planes;
 477
 478         for (d = 0; d < data->Depth; d++)
 479         {
 480             UWORD dmask = 1L << d;
 481             UWORD pmask = 0x80 >> startx;
 482             UBYTE *pl = *plane;
 483
 484             if (pl == (UBYTE *)-1) continue;
 485             if (pl == NULL) continue;
 486
 487             pl += planeoffset;
 488
 489             for (x = 0; x < width; x++)
 490             {
 491                 if (src[x] & dmask)
 492                 {
 493                     *pl |= pmask;
 494                 }
 495                 else
 496                 {
 497                     *pl &= ~pmask;
 498                 }
 499
 500                 if (pmask == 0x1)
 501                 {
 502                     pmask = 0x80;
 503                     pl++;
 504                 }
 505                 else
 506                 {
 507                     pmask >>= 1;
 508                 }
 509             } /* for (x = 0; x < msg->width; x++) */
 510
 511             plane++;
 512
 513         } /* for (d = 0; d < data->depth; d++) */
 514
 515         src = ((APTR)src + modulo);
 516         planeoffset += data->BytesPerRow;
 517     } /* for (y = 0; y < msg->height; y++) */
 518 }
 519
 520 VOID PBM__Hidd_BitMap__PutImage(OOP_Class *cl, OOP_Object *o,
 521                                 struct pHidd_BitMap_PutImage *msg)
 522 {
 523     struct planarbm_data *data = OOP_INST_DATA(cl, o);
 524
 525     if (!data->bitmap)
 526         return;
 527
 528     if ((msg->pixFmt != vHidd_StdPixFmt_Native) &&
 529         (msg->pixFmt != vHidd_StdPixFmt_Native32))
 530     {
 531         OOP_DoSuperMethod(cl, o, (OOP_Msg)msg);
 532         return;
 533     }
 534
 535     switch(msg->pixFmt)
 536     {
 537     case vHidd_StdPixFmt_Native:
 538         PBM_PutImage_Native(msg->pixels, msg->modulo, data->bitmap, msg->x, msg->y, msg->width, msg->height);
 539         break;
 540
 541     case vHidd_StdPixFmt_Native32:
 542         PBM_PutImage_Native32((HIDDT_Pixel *)msg->pixels, msg->modulo, data->bitmap, msg->x, msg->y, msg->width, msg->height);
 543         break;
 544
 545     }
 546 }
 547
 548 /****************************************************************************************/
 549
 550 VOID PBM__Hidd_BitMap__PutImageLUT(OOP_Class *cl, OOP_Object *o,
 551                                    struct pHidd_BitMap_PutImageLUT *msg)
 552 {
 553     struct planarbm_data *data = OOP_INST_DATA(cl, o);
 554
 555     if (!data->bitmap)
 556         return;
 557
 558     /* This is the same as PutImage() with vHidd_StdPixFmt_Native format */
 559     PBM_PutImage_Native(msg->pixels, msg->modulo, data->bitmap, msg->x, msg->y, msg->width, msg->height);
 560 }
 561
 562 /****************************************************************************************/
 563
 564 VOID PBM__Hidd_BitMap__GetImageLUT(OOP_Class *cl, OOP_Object *o,
 565                                    struct pHidd_BitMap_GetImageLUT *msg)
 566 {
 567     WORD                    x, y, d;
 568     UBYTE                   *pixarray = (UBYTE *)msg->pixels;
 569     UBYTE                   **plane;
 570     ULONG                   planeoffset;
 571     struct planarbm_data    *data;
 572     UBYTE                   prefill;
 573
 574     data = OOP_INST_DATA(cl, o);
 575
 576     if (!data->bitmap)
 577         return;
 578
 579     planeoffset = msg->y * data->bitmap->BytesPerRow + msg->x / 8;
 580
 581     prefill = 0;
 582     for (d = 0; d < data->bitmap->Depth; d++)
 583     {
 584         if (data->bitmap->Planes[d] == (UBYTE *)-1)
 585         {
 586             prefill |= (1L << d);
 587         }
 588     }
 589
 590     for (y = 0; y < msg->height; y++)
 591     {
 592         UBYTE *dest = pixarray;
 593
 594         plane = data->bitmap->Planes;
 595         for(x = 0; x < msg->width; x++)
 596         {
 597             dest[x] = prefill;
 598         }
 599
 600         for (d = 0; d < data->bitmap->Depth; d++)
 601         {
 602             UWORD dmask = 1L << d;
 603             UWORD pmask = 0x80 >> (msg->x & 7);
 604             UBYTE *pl = *plane;
 605
 606             if (pl == (UBYTE *)-1) continue;
 607             if (pl == NULL) continue;
 608
 609             pl += planeoffset;
 610
 611             for (x = 0; x < msg->width; x++)
 612             {
 613                 if (*pl & pmask)
 614                 {
 615                     dest[x] |= dmask;
 616                 }
 617                 else
 618                 {
 619                     dest[x] &= ~dmask;
 620                 }
 621
 622                 if (pmask == 0x1)
 623                 {
 624                     pmask = 0x80;
 625                     pl++;
 626                 }
 627                 else
 628                 {
 629                     pmask >>= 1;
 630                 }
 631
 632             } /* for(x = 0; x < msg->width; x++) */
 633
 634             plane++;
 635
 636         } /* for(d = 0; d < data->depth; d++) */
 637
 638         pixarray    += msg->modulo;
 639         planeoffset += data->bitmap->BytesPerRow;
 640
 641     } /* for(y = 0; y < msg->height; y++) */
 642
 643 }
 644
 645 /****************************************************************************************/
 646
 647 BOOL PBM__Hidd_PlanarBM__SetBitMap(OOP_Class *cl, OOP_Object *o,
 648                                    struct pHidd_PlanarBM_SetBitMap *msg)
 649 {
 650     return PBM_SetBitMap(cl, o, msg->bitMap);
 651 }
 652
 653 /****************************************************************************************/
 654
 655 BOOL PBM__Hidd_PlanarBM__GetBitMap(OOP_Class *cl, OOP_Object *o,
 656                                    struct pHidd_PlanarBM_GetBitMap *msg)
 657 {
 658     struct planarbm_data *data = OOP_INST_DATA(cl, o);
 659
 660     if (!data->bitmap)
 661         return FALSE;
 662
 663     /*
 664      * Totally obsolete and deprecated.
 665      * Just get aoHidd_PlanarBM_BitMap value instead.
 666      */
 667     CopyMem(data->bitmap, msg->bitMap, sizeof(struct BitMap));
 668     return TRUE;
 669 }