rom/hidds/graphics/planarbm.c

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