workbench/hidds/radeon/planarbm.c

   1 /*
   2     Copyright © 1995-2017, 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/gfx.h>
  21
  22 #include <string.h>
  23
  24 #include "ati.h"
  25
  26 #include <string.h>
  27
  28 #define DEBUG 0
  29 #include <aros/debug.h>
  30
  31 /****************************************************************************************/
  32
  33 #define _sd (&((struct atibase *)cl->UserData)->sd)
  34
  35 #undef HiddPCIDeviceAttrBase
  36 #undef HiddGfxAttrBase
  37 #undef HiddPixFmtAttrBase
  38 #undef HiddSyncAttrBase
  39 #undef HiddBitMapAttrBase
  40 #define HiddPCIDeviceAttrBase   (_sd->pciAttrBase)
  41 #define HiddATIBitMapAttrBase (_sd->atiBitMapAttrBase)
  42 #define HiddBitMapAttrBase      (_sd->bitMapAttrBase)
  43 #define HiddPixFmtAttrBase      (_sd->pixFmtAttrBase)
  44 #define HiddGfxAttrBase         (_sd->gfxAttrBase)
  45 #define HiddSyncAttrBase        (_sd->syncAttrBase)
  46 #define __IHidd_PlanarBM        (_sd->planarAttrBase)
  47
  48 /****************************************************************************************/
  49
  50 OOP_Object *ATIPlanBM__Root__New(OOP_Class *cl, OOP_Object *o, struct pRoot_New *msg)
  51 {
  52         IPTR width, height, depth;
  53
  54         BOOL  ok = TRUE;
  55
  56 #if 0
  57         /* Set the bitmaps' pixelformat */
  58         struct TagItem pf_tags[] =
  59         {
  60                         { aHidd_PixFmt_ColorModel   , vHidd_ColorModel_Palette  }, /* 0 */
  61                         { aHidd_PixFmt_Depth        , 0                         }, /* 1 */
  62                         { aHidd_PixFmt_BytesPerPixel, 0                         }, /* 2 */
  63                         { aHidd_PixFmt_BitsPerPixel , 0                         }, /* 3 */
  64                         { aHidd_PixFmt_StdPixFmt    , 0                         }, /* 4 */
  65                         { aHidd_PixFmt_CLUTShift    , 0                         }, /* 5 */
  66                         { aHidd_PixFmt_CLUTMask     , 0x000000FF                }, /* 6 */
  67                         { aHidd_PixFmt_RedMask      , 0x00FF0000                }, /* 7 */
  68                         { aHidd_PixFmt_GreenMask    , 0x0000FF00                }, /* 8 */
  69                         { aHidd_PixFmt_BlueMask     , 0x000000FF                }, /* 9 */
  70                         { aHidd_PixFmt_BitMapType   , vHidd_BitMapType_Planar   },
  71                         { TAG_DONE                  , 0UL                       }
  72         };
  73 #endif
  74
  75         struct planarbm_data *data;
  76         OOP_Object               *pf;
  77         APTR             p_pf = &pf;
  78
  79         o =(OOP_Object *)OOP_DoSuperMethod(cl, o, (OOP_Msg)msg);
  80         if (NULL == o)
  81                 return NULL;
  82
  83         data = OOP_INST_DATA(cl, o);
  84         memset(data, 0, sizeof  (*data));
  85
  86
  87         /* Get some data about the dimensions of the bitmap */
  88
  89         data->planes_alloced = (BOOL)GetTagData(aHidd_PlanarBM_AllocPlanes, TRUE, msg->attrList);
  90
  91         /* FIXME: Fix this hack */
  92         /* Because this class is used to emulate Amiga bitmaps, we
  93        have to see if it should have late initalisation
  94          */
  95         if (!data->planes_alloced)
  96                 return o; /* Late initialization */
  97
  98
  99         /* Not late initalization. Get some info on the bitmap */
 100         OOP_GetAttr(o, aHidd_BitMap_Width,      &width);
 101         OOP_GetAttr(o, aHidd_BitMap_Height,     &height);
 102         OOP_GetAttr(o,  aHidd_BitMap_PixFmt, (IPTR *)p_pf);
 103         OOP_GetAttr(pf, aHidd_PixFmt_Depth, (IPTR *)&depth);
 104
 105         /* We cache some info */
 106         data->bytesperrow         = ((width + 31) & ~31) / 8;
 107         data->rows                = height;
 108         data->depth               = depth;
 109
 110         if (ok)
 111         {
 112                 /* Allocate memory for plane array */
 113                 data->planes = AllocVec(sizeof (UBYTE *) * depth, MEMF_ANY|MEMF_CLEAR);
 114                 if (NULL == data->planes)
 115                         ok = FALSE;
 116                 else
 117                 {
 118                         UBYTE i;
 119
 120                         data->planebuf_size = depth;
 121
 122                         /* Allocate all the planes */
 123                         for ( i = 0; i < depth && ok; i ++)
 124                         {
 125                                 data->planes[i] = AllocVec(height * data->bytesperrow, MEMF_ANY|MEMF_CLEAR);
 126                                 if (NULL == data->planes[i])
 127                                         ok = FALSE;
 128                         }
 129                 }
 130         }
 131
 132         if (!ok)
 133         {
 134                 OOP_MethodID dispose_mid;
 135
 136                 dispose_mid = OOP_GetMethodID(IID_Root, moRoot_Dispose);
 137                 OOP_CoerceMethod(cl, o, (OOP_Msg)&dispose_mid);
 138
 139                 o = NULL;
 140         }
 141
 142         return o;
 143 }
 144
 145 /****************************************************************************************/
 146
 147 VOID ATIPlanBM__Root__Dispose(OOP_Class *cl, OOP_Object *o, OOP_Msg msg)
 148 {
 149         struct planarbm_data    *data;
 150         UBYTE                       i;
 151
 152         data = OOP_INST_DATA(cl, o);
 153
 154         if (data->planes_alloced)
 155         {
 156                 if (NULL != data->planes)
 157                 {
 158                         for (i = 0; i < data->depth; i ++)
 159                         {
 160                                 FreeVec(data->planes[i]);
 161                         }
 162                         FreeVec(data->planes);
 163                 }
 164         }
 165
 166         OOP_DoSuperMethod(cl, o, msg);
 167
 168         return;
 169 }
 170
 171 /****************************************************************************************/
 172
 173 VOID ATIPlanBM__Hidd_BitMap__PutPixel(OOP_Class *cl, OOP_Object *o,
 174                 struct pHidd_BitMap_PutPixel *msg)
 175 {
 176         UBYTE                       **plane;
 177         struct planarbm_data    *data;
 178         ULONG                       offset;
 179         ULONG                       mask;
 180         UBYTE                       pixel, notpixel;
 181         UBYTE                       i;
 182
 183         data = OOP_INST_DATA(cl, o);
 184
 185         /* bitmap in plane-mode */
 186         plane     = data->planes;
 187         offset    = msg->x / 8 + msg->y * data->bytesperrow;
 188         pixel     = 128 >> (msg->x % 8);
 189         notpixel  = ~pixel;
 190         mask      = 1;
 191
 192         for(i = 0; i < data->depth; i++, mask <<=1, plane ++)
 193         {
 194                 if ((*plane != NULL) && (*plane != (UBYTE *)-1))
 195                 {
 196                         if(msg->pixel & mask)
 197                         {
 198                                 *(*plane + offset) = *(*plane + offset) | pixel;
 199                         }
 200                         else
 201                         {
 202                                 *(*plane + offset) = *(*plane + offset) & notpixel;
 203                         }
 204                 }
 205         }
 206 }
 207
 208 /****************************************************************************************/
 209
 210 ULONG ATIPlanBM__Hidd_BitMap__GetPixel(OOP_Class *cl, OOP_Object *o,
 211                 struct pHidd_BitMap_GetPixel *msg)
 212 {
 213         struct planarbm_data    *data;
 214         UBYTE                       **plane;
 215         ULONG                       offset;
 216         ULONG                       i;
 217         UBYTE                       pixel;
 218         ULONG                       retval;
 219
 220         data = OOP_INST_DATA(cl, o);
 221
 222         plane     = data->planes;
 223         offset    = msg->x / 8 + msg->y * data->bytesperrow;
 224         pixel     = 128 >> (msg->x % 8);
 225         retval    = 0;
 226
 227         for(i = 0; i < data->depth; i++, plane ++)
 228         {
 229
 230                 if (*plane == (UBYTE *)-1)
 231                 {
 232                         retval = retval | (1 << i);
 233                 }
 234                 else if (*plane != NULL)
 235                 {
 236                         if(*(*plane + offset) & pixel)
 237                         {
 238                                 retval = retval | (1 << i);
 239                         }
 240                 }
 241         }
 242
 243         return retval;
 244 }
 245
 246 /****************************************************************************************/
 247
 248 VOID ATIPlanBM__Hidd_BitMap__PutImage(OOP_Class *cl, OOP_Object *o,
 249                 struct pHidd_BitMap_PutImage *msg)
 250 {
 251         WORD                        x, y, d;
 252         UBYTE                       *pixarray = (UBYTE *)msg->pixels;
 253         UBYTE                       **plane;
 254         ULONG                       planeoffset;
 255         struct planarbm_data    *data;
 256
 257         if ((msg->pixFmt != vHidd_StdPixFmt_Native) &&
 258                         (msg->pixFmt != vHidd_StdPixFmt_Native32))
 259         {
 260                 OOP_DoSuperMethod(cl, o, (OOP_Msg)msg);
 261                 return;
 262         }
 263
 264         data = OOP_INST_DATA(cl, o);
 265
 266         planeoffset = msg->y * data->bytesperrow + msg->x / 8;
 267
 268         for(y = 0; y < msg->height; y++)
 269         {
 270                 switch(msg->pixFmt)
 271                 {
 272                 case vHidd_StdPixFmt_Native:
 273                 {
 274                         UBYTE *src = pixarray;
 275
 276                         plane = data->planes;
 277
 278                         for(d = 0; d < data->depth; d++)
 279                         {
 280                                 ULONG dmask = 1L << d;
 281                                 ULONG pmask = 0x80 >> (msg->x & 7);
 282                                 UBYTE *pl = *plane;
 283
 284                                 if (pl == (UBYTE *)-1) continue;
 285                                 if (pl == NULL) continue;
 286
 287                                 pl += planeoffset;
 288
 289                                 for(x = 0; x < msg->width; x++)
 290                                 {
 291                                         if (src[x] & dmask)
 292                                         {
 293                                                 *pl |= pmask;
 294                                         }
 295                                         else
 296                                         {
 297                                                 *pl &= ~pmask;
 298                                         }
 299
 300                                         if (pmask == 0x1)
 301                                         {
 302                                                 pmask = 0x80;
 303                                                 pl++;
 304                                         }
 305                                         else
 306                                         {
 307                                                 pmask >>= 1;
 308                                         }
 309
 310                                 } /* for(x = 0; x < msg->width; x++) */
 311
 312                                 plane++;
 313
 314                         } /* for(d = 0; d < data->depth; d++) */
 315
 316                         pixarray += msg->modulo;
 317                         planeoffset += data->bytesperrow;
 318                 }
 319                 break;
 320
 321                 case vHidd_StdPixFmt_Native32:
 322                 {
 323                         HIDDT_Pixel *src = (HIDDT_Pixel *)pixarray;
 324
 325                         plane = data->planes;
 326
 327                         for(d = 0; d < data->depth; d++)
 328                         {
 329                                 ULONG dmask = 1L << d;
 330                                 ULONG pmask = 0x80 >> (msg->x & 7);
 331                                 UBYTE *pl = *plane;
 332
 333                                 if (pl == (UBYTE *)-1) continue;
 334                                 if (pl == NULL) continue;
 335
 336                                 pl += planeoffset;
 337
 338                                 for(x = 0; x < msg->width; x++)
 339                                 {
 340                                         if (src[x] & dmask)
 341                                         {
 342                                                 *pl |= pmask;
 343                                         }
 344                                         else
 345                                         {
 346                                                 *pl &= ~pmask;
 347                                         }
 348
 349                                         if (pmask == 0x1)
 350                                         {
 351                                                 pmask = 0x80;
 352                                                 pl++;
 353                                         }
 354                                         else
 355                                         {
 356                                                 pmask >>= 1;
 357                                         }
 358
 359                                 } /* for(x = 0; x < msg->width; x++) */
 360
 361                                 plane++;
 362
 363                         } /* for(d = 0; d < data->depth; d++) */
 364
 365                         pixarray += msg->modulo;
 366                         planeoffset += data->bytesperrow;
 367                 }
 368
 369                 break;
 370
 371                 } /* switch(msg->pixFmt) */
 372
 373         } /* for(y = 0; y < msg->height; y++) */
 374 }
 375
 376 /****************************************************************************************/
 377
 378 VOID ATIPlanBM__Hidd_BitMap__PutImageLUT(OOP_Class *cl, OOP_Object *o,
 379                 struct pHidd_BitMap_PutImageLUT *msg)
 380 {
 381         WORD                        x, y, d;
 382         UBYTE                       *pixarray = (UBYTE *)msg->pixels;
 383         UBYTE                       **plane;
 384         ULONG                       planeoffset;
 385         struct planarbm_data   *data;
 386
 387         data = OOP_INST_DATA(cl, o);
 388
 389         planeoffset = msg->y * data->bytesperrow + msg->x / 8;
 390
 391         for(y = 0; y < msg->height; y++)
 392         {
 393                 UBYTE *src = pixarray;
 394
 395                 plane = data->planes;
 396
 397                 for(d = 0; d < data->depth; d++)
 398                 {
 399                         ULONG dmask = 1L << d;
 400                         ULONG pmask = 0x80 >> (msg->x & 7);
 401                         UBYTE *pl = *plane;
 402
 403                         if (pl == (UBYTE *)-1) continue;
 404                         if (pl == NULL) continue;
 405
 406                         pl += planeoffset;
 407
 408                         for(x = 0; x < msg->width; x++)
 409                         {
 410                                 if (src[x] & dmask)
 411                                 {
 412                                         *pl |= pmask;
 413                                 }
 414                                 else
 415                                 {
 416                                         *pl &= ~pmask;
 417                                 }
 418
 419                                 if (pmask == 0x1)
 420                                 {
 421                                         pmask = 0x80;
 422                                         pl++;
 423                                 }
 424                                 else
 425                                 {
 426                                         pmask >>= 1;
 427                                 }
 428
 429                         } /* for(x = 0; x < msg->width; x++) */
 430
 431                         plane++;
 432
 433                 } /* for(d = 0; d < data->depth; d++) */
 434
 435                 pixarray += msg->modulo;
 436                 planeoffset += data->bytesperrow;
 437
 438         } /* for(y = 0; y < msg->height; y++) */
 439 }
 440
 441 /****************************************************************************************/
 442
 443 VOID ATIPlanBM__Hidd_BitMap__GetImageLUT(OOP_Class *cl, OOP_Object *o,
 444                 struct pHidd_BitMap_GetImageLUT *msg)
 445 {
 446         WORD                        x, y, d;
 447         UBYTE                       *pixarray = (UBYTE *)msg->pixels;
 448         UBYTE                       **plane;
 449         ULONG                       planeoffset;
 450         struct planarbm_data    *data;
 451         UBYTE                       prefill;
 452
 453         data = OOP_INST_DATA(cl, o);
 454
 455         planeoffset = msg->y * data->bytesperrow + msg->x / 8;
 456
 457         prefill = 0;
 458         for(d = 0; d < data->depth; d++)
 459         {
 460                 if (data->planes[d] == (UBYTE *)-1)
 461                 {
 462                         prefill |= (1L << d);
 463                 }
 464         }
 465
 466         for(y = 0; y < msg->height; y++)
 467         {
 468                 UBYTE *dest = pixarray;
 469
 470                 plane = data->planes;
 471
 472                 for(x = 0; x < msg->width; x++)
 473                 {
 474                         dest[x] = prefill;
 475                 }
 476
 477                 for(d = 0; d < data->depth; d++)
 478                 {
 479                         ULONG dmask = 1L << d;
 480                         ULONG pmask = 0x80 >> (msg->x & 7);
 481                         UBYTE *pl = *plane;
 482
 483                         if (pl == (UBYTE *)-1) continue;
 484                         if (pl == NULL) continue;
 485
 486                         pl += planeoffset;
 487
 488                         for(x = 0; x < msg->width; x++)
 489                         {
 490                                 if (*pl & pmask)
 491                                 {
 492                                         dest[x] |= dmask;
 493                                 }
 494                                 else
 495                                 {
 496                                         dest[x] &= ~dmask;
 497                                 }
 498
 499                                 if (pmask == 0x1)
 500                                 {
 501                                         pmask = 0x80;
 502                                         pl++;
 503                                 }
 504                                 else
 505                                 {
 506                                         pmask >>= 1;
 507                                 }
 508
 509                         } /* for(x = 0; x < msg->width; x++) */
 510
 511                         plane++;
 512
 513                 } /* for(d = 0; d < data->depth; d++) */
 514
 515                 pixarray += msg->modulo;
 516                 planeoffset += data->bytesperrow;
 517
 518         } /* for(y = 0; y < msg->height; y++) */
 519
 520 }
 521
 522 /****************************************************************************************/
 523
 524 VOID ATIPlanBM__Hidd_BitMap__BlitColorExpansion(OOP_Class *cl, OOP_Object *o,
 525                 struct pHidd_BitMap_BlitColorExpansion *msg)
 526 {
 527         WORD                        x, y, d;
 528         UBYTE                       **plane;
 529         UBYTE                       *mask;
 530         ULONG                       planeoffset /*, maskoffset*/;
 531         ULONG                       cemd, fg, bg;
 532         BOOL                        opaque;
 533         OOP_Object                  *gc = msg->gc;
 534         struct planarbm_data    *data, *maskdata;
 535
 536         data     = OOP_INST_DATA(cl, o);
 537
 538         cemd = GC_COLEXP(gc);
 539         fg   = GC_FG(gc);
 540         bg   = GC_BG(gc);
 541
 542         opaque = (cemd & vHidd_GC_ColExp_Opaque) ? TRUE : FALSE;
 543
 544         planeoffset = msg->destY * data->bytesperrow + msg->destX / 8;
 545
 546         if (OOP_OCLASS(msg->srcBitMap) == cl)
 547         {
 548                 /* srcBitMap is a planarbm class object */
 549
 550                 maskdata = OOP_INST_DATA(cl, msg->srcBitMap);
 551                 mask     = maskdata->planes[0];
 552                 mask     += msg->srcY * maskdata->bytesperrow + msg->srcX / 8;
 553
 554                 for(y = 0; y < msg->height; y++)
 555                 {
 556                         plane = data->planes;
 557
 558                         for(d = 0; d < data->depth; d++)
 559                         {
 560                                 ULONG dmask = 1L << d;
 561                                 ULONG pmask = 0x80 >> (msg->destX & 7);
 562                                 ULONG mmask = 0x80 >> (msg->srcX & 7);
 563                                 BOOL  fgset = (fg & dmask) ? TRUE : FALSE;
 564                                 BOOL  bgset = (bg & dmask) ? TRUE : FALSE;
 565
 566                                 UBYTE *pl = *plane;
 567                                 UBYTE *msk = mask;
 568
 569                                 if (pl == (UBYTE *)-1) continue;
 570                                 if (pl == NULL) continue;
 571
 572                                 pl += planeoffset;
 573
 574                                 for(x = 0; x < msg->width; x++)
 575                                 {
 576                                         if (*msk & mmask)
 577                                         {
 578                                                 if (fgset)
 579                                                         *pl |= pmask;
 580                                                 else
 581                                                         *pl &= ~pmask;
 582                                         }
 583                                         else if (opaque)
 584                                         {
 585                                                 if (bgset)
 586                                                         *pl |= pmask;
 587                                                 else
 588                                                         *pl &= ~pmask;
 589                                         }
 590
 591                                         if (pmask == 0x1)
 592                                         {
 593                                                 pmask = 0x80;
 594                                                 pl++;
 595                                         }
 596                                         else
 597                                         {
 598                                                 pmask >>= 1;
 599                                         }
 600
 601                                         if (mmask == 0x1)
 602                                         {
 603                                                 mmask = 0x80;
 604                                                 msk++;
 605                                         }
 606                                         else
 607                                         {
 608                                                 mmask >>= 1;
 609                                         }
 610
 611                                 } /* for(x = 0; x < msg->width; x++) */
 612
 613                                 plane++;
 614
 615                         } /* for(d = 0; d < data->depth; d++) */
 616
 617                         mask    += maskdata->bytesperrow;
 618                         planeoffset += data->bytesperrow;
 619
 620                 } /* for(y = 0; y < msg->height; y++) */
 621
 622         } /* if (OOP_OCLASS(msg->srcBitMap) == cl) */
 623         else
 624         {
 625                 HIDDT_Pixel *maskline;
 626
 627                 maskline = AllocVec(msg->width * sizeof(HIDDT_Pixel), MEMF_PUBLIC);
 628                 if (!maskline)
 629                 {
 630                         OOP_DoSuperMethod(cl, o, (OOP_Msg)msg);
 631                         return;
 632                 }
 633
 634                 for(y = 0; y < msg->height; y++)
 635                 {
 636                         plane = data->planes;
 637
 638                         struct pHidd_BitMap_GetImage __m = {
 639                                         _sd->mid_GetImage,
 640                                         (UBYTE *)maskline,
 641                                         0,
 642                                         msg->srcX,
 643                                         msg->srcY + y,
 644                                         msg->width,
 645                                         1,
 646                                         vHidd_StdPixFmt_Native32
 647                                     }, *m = &__m;
 648
 649                                     OOP_DoMethod(msg->srcBitMap, (OOP_Msg)m);
 650
 651                         for(d = 0; d < data->depth; d++)
 652                         {
 653                                 ULONG dmask = 1L << d;
 654                                 ULONG pmask = 0x80 >> (msg->destX & 7);
 655                                 BOOL  fgset = (fg & dmask) ? TRUE : FALSE;
 656                                 BOOL  bgset = (bg & dmask) ? TRUE : FALSE;
 657
 658                                 UBYTE *pl = *plane;
 659
 660                                 if (pl == (UBYTE *)-1) continue;
 661                                 if (pl == NULL) continue;
 662
 663                                 pl += planeoffset;
 664
 665                                 for(x = 0; x < msg->width; x++)
 666                                 {
 667                                         if (maskline[x])
 668                                         {
 669                                                 if (fgset)
 670                                                         *pl |= pmask;
 671                                                 else
 672                                                         *pl &= ~pmask;
 673                                         }
 674                                         else if (opaque)
 675                                         {
 676                                                 if (bgset)
 677                                                         *pl |= pmask;
 678                                                 else
 679                                                         *pl &= ~pmask;
 680                                         }
 681
 682                                         if (pmask == 0x1)
 683                                         {
 684                                                 pmask = 0x80;
 685                                                 pl++;
 686                                         }
 687                                         else
 688                                         {
 689                                                 pmask >>= 1;
 690                                         }
 691
 692                                 } /* for(x = 0; x < msg->width; x++) */
 693
 694                                 plane++;
 695
 696                         } /* for(d = 0; d < data->depth; d++) */
 697
 698                         planeoffset += data->bytesperrow;
 699
 700                 } /* for(y = 0; y < msg->height; y++) */
 701
 702                 FreeVec(maskline);
 703
 704         } /* if (OOP_OCLASS(msg->srcBitMap) == cl) else ... */
 705 }
 706
 707
 708 /****************************************************************************************/
 709
 710 BOOL ATIPlanBM__Hidd_PlanarBM__SetBitMap(OOP_Class *cl, OOP_Object *o,
 711                 struct pHidd_PlanarBM_SetBitMap *msg)
 712 {
 713         struct planarbm_data *data;
 714         struct BitMap            *bm;
 715
 716         struct TagItem           pftags[] =
 717         {
 718                         { aHidd_PixFmt_Depth        , 0UL                       },      /* 0 */
 719                         { aHidd_PixFmt_BitsPerPixel , 0UL                       },      /* 1 */
 720                         { aHidd_PixFmt_BytesPerPixel, 1UL                       },      /* 2 */
 721                         { aHidd_PixFmt_ColorModel   , vHidd_ColorModel_Palette  },      /* 3 */
 722                         { aHidd_PixFmt_BitMapType   , vHidd_BitMapType_Planar   },      /* 4 */
 723                         { aHidd_PixFmt_CLUTShift    , 0UL                       },      /* 5 */
 724                         { aHidd_PixFmt_CLUTMask     , 0x000000FF                },      /* 6 */
 725                         { aHidd_PixFmt_RedMask      , 0x00FF0000                },      /* 7 */
 726                         { aHidd_PixFmt_GreenMask    , 0x0000FF00                },      /* 8 */
 727                         { aHidd_PixFmt_BlueMask     , 0x000000FF                },      /* 9 */
 728                         { TAG_DONE                  , 0UL                       }       /* 7 */
 729         };
 730         struct TagItem          bmtags[] =
 731         {
 732                         { aHidd_BitMap_Width        , 0UL },
 733                         { aHidd_BitMap_Height       , 0UL },
 734                         { TAG_DONE                  , 0UL }
 735         };
 736
 737         ULONG i;
 738
 739         data = OOP_INST_DATA(cl, o);
 740         bm = msg->bitMap;
 741
 742         if (data->planes_alloced)
 743         {
 744                 D(bug(" !!!!! PlanarBM: Trying to set bitmap in one that allready has planes allocated\n"));
 745                 return FALSE;
 746         }
 747
 748         /* Check if plane array allready allocated */
 749         if (NULL != data->planes)
 750         {
 751                 if (bm->Depth > data->planebuf_size)
 752                 {
 753                         FreeVec(data->planes);
 754                         data->planes = NULL;
 755                 }
 756         }
 757
 758         if (NULL == data->planes)
 759         {
 760                 data->planes = AllocVec(sizeof (UBYTE *) * bm->Depth, MEMF_CLEAR);
 761
 762                 if (NULL == data->planes)
 763                         return FALSE;
 764
 765                 data->planebuf_size = bm->Depth;
 766         }
 767
 768
 769         /* Update the planes */
 770         for (i = 0; i < data->planebuf_size; i ++)
 771         {
 772                 if (i < bm->Depth)
 773                         data->planes[i] = bm->Planes[i];
 774                 else
 775                         data->planes[i] = NULL;
 776         }
 777
 778         data->depth             = bm->Depth;
 779         data->bytesperrow       = bm->BytesPerRow;
 780         data->rows              = bm->Rows;
 781
 782         pftags[0].ti_Data = bm->Depth;  /* PixFmt_Depth */
 783         pftags[1].ti_Data = bm->Depth;  /* PixFmt_BitsPerPixel */
 784
 785         bmtags[0].ti_Data = bm->BytesPerRow * 8;
 786         bmtags[1].ti_Data = bm->Rows;
 787         bmtags[2].ti_Data = (IPTR)pftags;
 788
 789         struct pHidd_BitMap_SetBitMapTags {
 790                 OOP_MethodID mID;
 791                 struct TagItem *tags;
 792             } __m = {
 793                 OOP_GetMethodID(IID_Hidd_BitMap, num_Hidd_BitMap_Methods),
 794                 bmtags
 795             }, *m = &__m;
 796
 797         /* Call private bitmap method to update superclass */
 798         if (!OOP_DoMethod(o, (OOP_Msg)m))
 799         {
 800                 ULONG i;
 801
 802                 for (i = 0; i < data->planebuf_size; i ++)
 803                 {
 804                         data->planes[i] = NULL;
 805                 }
 806         }
 807
 808         return TRUE;
 809 }
 810
 811 /****************************************************************************************/