workbench/hidds/hidd.nvidia/planarbm.c

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