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