workbench/hidds/hidd.nouveau/planarbm.c

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