?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Fixed binary search: no more infinite loops when vendor is unknown.
[tangerine.git] / arch / common / hidd.radeon / planarbm.c
blobfbd1fb32b268e7a5effe347b44a1c544e0092ddb
1 /*
2 Copyright � 1995-2001, The AROS Development Team. All rights reserved.
3 $Id: planarbm.c 30792 2009-03-07 22:40:04Z neil $
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 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 *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 #warning 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 if (NULL != data->planes[i])
161 {
162 FreeVec(data->planes[i]);
163 }
164 }
165 FreeVec(data->planes);
166 }
167 }
168
169 OOP_DoSuperMethod(cl, o, msg);
170
171 return;
172 }
173
174 /****************************************************************************************/
175
176 VOID ATIPlanBM__Hidd_BitMap__PutPixel(OOP_Class *cl, OOP_Object *o,
177 struct pHidd_BitMap_PutPixel *msg)
178 {
179 UBYTE **plane;
180 struct planarbm_data *data;
181 ULONG offset;
182 ULONG mask;
183 UBYTE pixel, notpixel;
184 UBYTE i;
185
186 data = OOP_INST_DATA(cl, o);
187
188 /* bitmap in plane-mode */
189 plane = data->planes;
190 offset = msg->x / 8 + msg->y * data->bytesperrow;
191 pixel = 128 >> (msg->x % 8);
192 notpixel = ~pixel;
193 mask = 1;
194
195 for(i = 0; i < data->depth; i++, mask <<=1, plane ++)
196 {
197 if ((*plane != NULL) && (*plane != (UBYTE *)-1))
198 {
199 if(msg->pixel & mask)
200 {
201 *(*plane + offset) = *(*plane + offset) | pixel;
202 }
203 else
204 {
205 *(*plane + offset) = *(*plane + offset) & notpixel;
206 }
207 }
208 }
209 }
210
211 /****************************************************************************************/
212
213 ULONG ATIPlanBM__Hidd_BitMap__GetPixel(OOP_Class *cl, OOP_Object *o,
214 struct pHidd_BitMap_GetPixel *msg)
215 {
216 struct planarbm_data *data;
217 UBYTE **plane;
218 ULONG offset;
219 ULONG i;
220 UBYTE pixel;
221 ULONG retval;
222
223 data = OOP_INST_DATA(cl, o);
224
225 plane = data->planes;
226 offset = msg->x / 8 + msg->y * data->bytesperrow;
227 pixel = 128 >> (msg->x % 8);
228 retval = 0;
229
230 for(i = 0; i < data->depth; i++, plane ++)
231 {
232
233 if (*plane == (UBYTE *)-1)
234 {
235 retval = retval | (1 << i);
236 }
237 else if (*plane != NULL)
238 {
239 if(*(*plane + offset) & pixel)
240 {
241 retval = retval | (1 << i);
242 }
243 }
244 }
245
246 return retval;
247 }
248
249 /****************************************************************************************/
250
251 VOID ATIPlanBM__Hidd_BitMap__PutImage(OOP_Class *cl, OOP_Object *o,
252 struct pHidd_BitMap_PutImage *msg)
253 {
254 WORD x, y, d;
255 UBYTE *pixarray = (UBYTE *)msg->pixels;
256 UBYTE **plane;
257 ULONG planeoffset;
258 struct planarbm_data *data;
259
260 if ((msg->pixFmt != vHidd_StdPixFmt_Native) &&
261 (msg->pixFmt != vHidd_StdPixFmt_Native32))
262 {
263 OOP_DoSuperMethod(cl, o, (OOP_Msg)msg);
264 return;
265 }
266
267 data = OOP_INST_DATA(cl, o);
268
269 planeoffset = msg->y * data->bytesperrow + msg->x / 8;
270
271 for(y = 0; y < msg->height; y++)
272 {
273 switch(msg->pixFmt)
274 {
275 case vHidd_StdPixFmt_Native:
276 {
277 UBYTE *src = pixarray;
278
279 plane = data->planes;
280
281 for(d = 0; d < data->depth; d++)
282 {
283 ULONG dmask = 1L << d;
284 ULONG pmask = 0x80 >> (msg->x & 7);
285 UBYTE *pl = *plane;
286
287 if (pl == (UBYTE *)-1) continue;
288 if (pl == NULL) continue;
289
290 pl += planeoffset;
291
292 for(x = 0; x < msg->width; x++)
293 {
294 if (src[x] & dmask)
295 {
296 *pl |= pmask;
297 }
298 else
299 {
300 *pl &= ~pmask;
301 }
302
303 if (pmask == 0x1)
304 {
305 pmask = 0x80;
306 pl++;
307 }
308 else
309 {
310 pmask >>= 1;
311 }
312
313 } /* for(x = 0; x < msg->width; x++) */
314
315 plane++;
316
317 } /* for(d = 0; d < data->depth; d++) */
318
319 pixarray += msg->modulo;
320 planeoffset += data->bytesperrow;
321 }
322 break;
323
324 case vHidd_StdPixFmt_Native32:
325 {
326 HIDDT_Pixel *src = (HIDDT_Pixel *)pixarray;
327
328 plane = data->planes;
329
330 for(d = 0; d < data->depth; d++)
331 {
332 ULONG dmask = 1L << d;
333 ULONG pmask = 0x80 >> (msg->x & 7);
334 UBYTE *pl = *plane;
335
336 if (pl == (UBYTE *)-1) continue;
337 if (pl == NULL) continue;
338
339 pl += planeoffset;
340
341 for(x = 0; x < msg->width; x++)
342 {
343 if (src[x] & dmask)
344 {
345 *pl |= pmask;
346 }
347 else
348 {
349 *pl &= ~pmask;
350 }
351
352 if (pmask == 0x1)
353 {
354 pmask = 0x80;
355 pl++;
356 }
357 else
358 {
359 pmask >>= 1;
360 }
361
362 } /* for(x = 0; x < msg->width; x++) */
363
364 plane++;
365
366 } /* for(d = 0; d < data->depth; d++) */
367
368 pixarray += msg->modulo;
369 planeoffset += data->bytesperrow;
370 }
371
372 break;
373
374 } /* switch(msg->pixFmt) */
375
376 } /* for(y = 0; y < msg->height; y++) */
377 }
378
379 /****************************************************************************************/
380
381 VOID ATIPlanBM__Hidd_BitMap__PutImageLUT(OOP_Class *cl, OOP_Object *o,
382 struct pHidd_BitMap_PutImageLUT *msg)
383 {
384 WORD x, y, d;
385 UBYTE *pixarray = (UBYTE *)msg->pixels;
386 UBYTE **plane;
387 ULONG planeoffset;
388 struct planarbm_data *data;
389
390 data = OOP_INST_DATA(cl, o);
391
392 planeoffset = msg->y * data->bytesperrow + msg->x / 8;
393
394 for(y = 0; y < msg->height; y++)
395 {
396 UBYTE *src = pixarray;
397
398 plane = data->planes;
399
400 for(d = 0; d < data->depth; d++)
401 {
402 ULONG dmask = 1L << d;
403 ULONG pmask = 0x80 >> (msg->x & 7);
404 UBYTE *pl = *plane;
405
406 if (pl == (UBYTE *)-1) continue;
407 if (pl == NULL) continue;
408
409 pl += planeoffset;
410
411 for(x = 0; x < msg->width; x++)
412 {
413 if (src[x] & dmask)
414 {
415 *pl |= pmask;
416 }
417 else
418 {
419 *pl &= ~pmask;
420 }
421
422 if (pmask == 0x1)
423 {
424 pmask = 0x80;
425 pl++;
426 }
427 else
428 {
429 pmask >>= 1;
430 }
431
432 } /* for(x = 0; x < msg->width; x++) */
433
434 plane++;
435
436 } /* for(d = 0; d < data->depth; d++) */
437
438 pixarray += msg->modulo;
439 planeoffset += data->bytesperrow;
440
441 } /* for(y = 0; y < msg->height; y++) */
442 }
443
444 /****************************************************************************************/
445
446 VOID ATIPlanBM__Hidd_BitMap__GetImageLUT(OOP_Class *cl, OOP_Object *o,
447 struct pHidd_BitMap_GetImageLUT *msg)
448 {
449 WORD x, y, d;
450 UBYTE *pixarray = (UBYTE *)msg->pixels;
451 UBYTE **plane;
452 ULONG planeoffset;
453 struct planarbm_data *data;
454 UBYTE prefill;
455
456 data = OOP_INST_DATA(cl, o);
457
458 planeoffset = msg->y * data->bytesperrow + msg->x / 8;
459
460 prefill = 0;
461 for(d = 0; d < data->depth; d++)
462 {
463 if (data->planes[d] == (UBYTE *)-1)
464 {
465 prefill |= (1L << d);
466 }
467 }
468
469 for(y = 0; y < msg->height; y++)
470 {
471 UBYTE *dest = pixarray;
472
473 plane = data->planes;
474
475 for(x = 0; x < msg->width; x++)
476 {
477 dest[x] = prefill;
478 }
479
480 for(d = 0; d < data->depth; d++)
481 {
482 ULONG dmask = 1L << d;
483 ULONG pmask = 0x80 >> (msg->x & 7);
484 UBYTE *pl = *plane;
485
486 if (pl == (UBYTE *)-1) continue;
487 if (pl == NULL) continue;
488
489 pl += planeoffset;
490
491 for(x = 0; x < msg->width; x++)
492 {
493 if (*pl & pmask)
494 {
495 dest[x] |= dmask;
496 }
497 else
498 {
499 dest[x] &= ~dmask;
500 }
501
502 if (pmask == 0x1)
503 {
504 pmask = 0x80;
505 pl++;
506 }
507 else
508 {
509 pmask >>= 1;
510 }
511
512 } /* for(x = 0; x < msg->width; x++) */
513
514 plane++;
515
516 } /* for(d = 0; d < data->depth; d++) */
517
518 pixarray += msg->modulo;
519 planeoffset += data->bytesperrow;
520
521 } /* for(y = 0; y < msg->height; y++) */
522
523 }
524
525 /****************************************************************************************/
526
527 VOID ATIPlanBM__Hidd_BitMap__BlitColorExpansion(OOP_Class *cl, OOP_Object *o,
528 struct pHidd_BitMap_BlitColorExpansion *msg)
529 {
530 WORD x, y, d;
531 UBYTE **plane;
532 UBYTE *mask;
533 ULONG planeoffset /*, maskoffset*/;
534 ULONG cemd, fg, bg;
535 BOOL opaque;
536 OOP_Object *gc = msg->gc;
537 struct planarbm_data *data, *maskdata;
538
539 data = OOP_INST_DATA(cl, o);
540
541 cemd = GC_COLEXP(gc);
542 fg = GC_FG(gc);
543 bg = GC_BG(gc);
544
545 opaque = (cemd & vHidd_GC_ColExp_Opaque) ? TRUE : FALSE;
546
547 planeoffset = msg->destY * data->bytesperrow + msg->destX / 8;
548
549 if (OOP_OCLASS(msg->srcBitMap) == cl)
550 {
551 /* srcBitMap is a planarbm class object */
552
553 maskdata = OOP_INST_DATA(cl, msg->srcBitMap);
554 mask = maskdata->planes[0];
555 mask += msg->srcY * maskdata->bytesperrow + msg->srcX / 8;
556
557 for(y = 0; y < msg->height; y++)
558 {
559 plane = data->planes;
560
561 for(d = 0; d < data->depth; d++)
562 {
563 ULONG dmask = 1L << d;
564 ULONG pmask = 0x80 >> (msg->destX & 7);
565 ULONG mmask = 0x80 >> (msg->srcX & 7);
566 BOOL fgset = (fg & dmask) ? TRUE : FALSE;
567 BOOL bgset = (bg & dmask) ? TRUE : FALSE;
568
569 UBYTE *pl = *plane;
570 UBYTE *msk = mask;
571
572 if (pl == (UBYTE *)-1) continue;
573 if (pl == NULL) continue;
574
575 pl += planeoffset;
576
577 for(x = 0; x < msg->width; x++)
578 {
579 if (*msk & mmask)
580 {
581 if (fgset)
582 *pl |= pmask;
583 else
584 *pl &= ~pmask;
585 }
586 else if (opaque)
587 {
588 if (bgset)
589 *pl |= pmask;
590 else
591 *pl &= ~pmask;
592 }
593
594 if (pmask == 0x1)
595 {
596 pmask = 0x80;
597 pl++;
598 }
599 else
600 {
601 pmask >>= 1;
602 }
603
604 if (mmask == 0x1)
605 {
606 mmask = 0x80;
607 msk++;
608 }
609 else
610 {
611 mmask >>= 1;
612 }
613
614 } /* for(x = 0; x < msg->width; x++) */
615
616 plane++;
617
618 } /* for(d = 0; d < data->depth; d++) */
619
620 mask += maskdata->bytesperrow;
621 planeoffset += data->bytesperrow;
622
623 } /* for(y = 0; y < msg->height; y++) */
624
625 } /* if (OOP_OCLASS(msg->srcBitMap) == cl) */
626 else
627 {
628 HIDDT_Pixel *maskline;
629
630 maskline = AllocVec(msg->width * sizeof(HIDDT_Pixel), MEMF_PUBLIC);
631 if (!maskline)
632 {
633 OOP_DoSuperMethod(cl, o, (OOP_Msg)msg);
634 return;
635 }
636
637 for(y = 0; y < msg->height; y++)
638 {
639 plane = data->planes;
640
641 struct pHidd_BitMap_GetImage __m = {
642 _sd->mid_GetImage,
643 (UBYTE *)maskline,
644 0,
645 msg->srcX,
646 msg->srcY + y,
647 msg->width,
648 1,
649 vHidd_StdPixFmt_Native32
650 }, *m = &__m;
651
652 OOP_DoMethod(msg->srcBitMap, (OOP_Msg)m);
653
654 for(d = 0; d < data->depth; d++)
655 {
656 ULONG dmask = 1L << d;
657 ULONG pmask = 0x80 >> (msg->destX & 7);
658 BOOL fgset = (fg & dmask) ? TRUE : FALSE;
659 BOOL bgset = (bg & dmask) ? TRUE : FALSE;
660
661 UBYTE *pl = *plane;
662
663 if (pl == (UBYTE *)-1) continue;
664 if (pl == NULL) continue;
665
666 pl += planeoffset;
667
668 for(x = 0; x < msg->width; x++)
669 {
670 if (maskline[x])
671 {
672 if (fgset)
673 *pl |= pmask;
674 else
675 *pl &= ~pmask;
676 }
677 else if (opaque)
678 {
679 if (bgset)
680 *pl |= pmask;
681 else
682 *pl &= ~pmask;
683 }
684
685 if (pmask == 0x1)
686 {
687 pmask = 0x80;
688 pl++;
689 }
690 else
691 {
692 pmask >>= 1;
693 }
694
695 } /* for(x = 0; x < msg->width; x++) */
696
697 plane++;
698
699 } /* for(d = 0; d < data->depth; d++) */
700
701 planeoffset += data->bytesperrow;
702
703 } /* for(y = 0; y < msg->height; y++) */
704
705 FreeVec(maskline);
706
707 } /* if (OOP_OCLASS(msg->srcBitMap) == cl) else ... */
708 }
709
710
711 /****************************************************************************************/
712
713 BOOL ATIPlanBM__Hidd_PlanarBM__SetBitMap(OOP_Class *cl, OOP_Object *o,
714 struct pHidd_PlanarBM_SetBitMap *msg)
715 {
716 struct planarbm_data *data;
717 struct BitMap *bm;
718
719 struct TagItem pftags[] =
720 {
721 { aHidd_PixFmt_Depth , 0UL }, /* 0 */
722 { aHidd_PixFmt_BitsPerPixel , 0UL }, /* 1 */
723 { aHidd_PixFmt_BytesPerPixel, 1UL }, /* 2 */
724 { aHidd_PixFmt_ColorModel , vHidd_ColorModel_Palette }, /* 3 */
725 { aHidd_PixFmt_BitMapType , vHidd_BitMapType_Planar }, /* 4 */
726 { aHidd_PixFmt_CLUTShift , 0UL }, /* 5 */
727 { aHidd_PixFmt_CLUTMask , 0x000000FF }, /* 6 */
728 { aHidd_PixFmt_RedMask , 0x00FF0000 }, /* 7 */
729 { aHidd_PixFmt_GreenMask , 0x0000FF00 }, /* 8 */
730 { aHidd_PixFmt_BlueMask , 0x000000FF }, /* 9 */
731 { TAG_DONE , 0UL } /* 7 */
732 };
733 struct TagItem bmtags[] =
734 {
735 { aHidd_BitMap_Width , 0UL },
736 { aHidd_BitMap_Height , 0UL },
737 { aHidd_BitMap_PixFmtTags , 0UL },
738 { TAG_DONE , 0UL }
739 };
740
741 ULONG i;
742
743 data = OOP_INST_DATA(cl, o);
744 bm = msg->bitMap;
745
746 if (data->planes_alloced)
747 {
748 D(bug(" !!!!! PlanarBM: Trying to set bitmap in one that allready has planes allocated\n"));
749 return FALSE;
750 }
751
752 /* Check if plane array allready allocated */
753 if (NULL != data->planes)
754 {
755 if (bm->Depth > data->planebuf_size)
756 {
757 FreeVec(data->planes);
758 data->planes = NULL;
759 }
760 }
761
762 if (NULL == data->planes)
763 {
764 data->planes = AllocVec(sizeof (UBYTE *) * bm->Depth, MEMF_CLEAR);
765
766 if (NULL == data->planes)
767 return FALSE;
768
769 data->planebuf_size = bm->Depth;
770 }
771
772
773 /* Update the planes */
774 for (i = 0; i < data->planebuf_size; i ++)
775 {
776 if (i < bm->Depth)
777 data->planes[i] = bm->Planes[i];
778 else
779 data->planes[i] = NULL;
780 }
781
782 data->depth = bm->Depth;
783 data->bytesperrow = bm->BytesPerRow;
784 data->rows = bm->Rows;
785
786 pftags[0].ti_Data = bm->Depth; /* PixFmt_Depth */
787 pftags[1].ti_Data = bm->Depth; /* PixFmt_BitsPerPixel */
788
789 bmtags[0].ti_Data = bm->BytesPerRow * 8;
790 bmtags[1].ti_Data = bm->Rows;
791 bmtags[2].ti_Data = (IPTR)pftags;
792
793 struct pHidd_BitMap_SetBitMapTags {
794 OOP_MethodID mID;
795 struct TagItem *tags;
796 } __m = {
797 OOP_GetMethodID(IID_Hidd_BitMap, num_Hidd_BitMap_Methods),
798 bmtags
799 }, *m = &__m;
800
801 /* Call private bitmap method to update superclass */
802 if (!OOP_DoMethod(o, (OOP_Msg)m))
803 {
804 ULONG i;
805
806 for (i = 0; i < data->planebuf_size; i ++)
807 {
808 data->planes[i] = NULL;
809 }
810 }
811
812 return TRUE;
813 }
814
815 /****************************************************************************************/
A totally sweet operating system