?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Check for SYS/GL during library init. Reason is that
[AROS.git] / workbench / hidds / radeon / planarbm.c
blobc43f51dccad479302bba445622c5291849e8d8a4
1 /*
2 Copyright � 1995-2013, 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 "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 /****************************************************************************************/
Mirror of AROS' svn.