?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Fixed a warning (missing type cast)
[tangerine.git] / rom / graphics / graphics_driver.c
blob5cdd1a2c43f89d90b60030bacf34087949b9fc87
1 /*
2 Copyright © 1995-2006, The AROS Development Team. All rights reserved.
3 $Id$
4
5 Desc: Driver for using gfxhidd for gfx output
6 Lang: english
7 */
8
9
10
11 #include <proto/exec.h>
12 #include <proto/graphics.h>
13 #include <proto/layers.h>
14 #include <proto/arossupport.h>
15 #include <proto/utility.h>
16 #include <proto/oop.h>
17
18 #include <exec/memory.h>
19 #include <exec/semaphores.h>
20 #include <clib/macros.h>
21
22 #include <graphics/rastport.h>
23 #include <graphics/gfxbase.h>
24 #include <graphics/text.h>
25 #include <graphics/view.h>
26 #include <graphics/layers.h>
27 #include <graphics/clip.h>
28 #include <graphics/gfxmacros.h>
29 #include <graphics/regions.h>
30 #include <graphics/scale.h>
31
32 #include <oop/oop.h>
33 #include <utility/tagitem.h>
34 #include <aros/asmcall.h>
35
36 #include <intuition/intuition.h>
37
38 #include <hidd/graphics.h>
39
40 #include <cybergraphx/cybergraphics.h>
41
42 #include <stdio.h>
43 #include <string.h>
44
45 #include "graphics_intern.h"
46 #include "graphics_internal.h"
47 #include "intregions.h"
48 #include "dispinfo.h"
49 #include "gfxfuncsupport.h"
50 #include "fontsupport.h"
51
52 #define SDEBUG 0
53 #define DEBUG 0
54 #include <aros/debug.h>
55
56
57 static BOOL init_cursor(struct GfxBase *GfxBase);
58 static VOID cleanup_cursor(struct GfxBase *GfxBase);
59
60 struct rgbpix_render_data
61 {
62 HIDDT_Pixel pixel;
63 };
64
65
66 static LONG rgbpix_write(APTR pr_data, OOP_Object *bm, OOP_Object *gc,
67 LONG x, LONG y, struct GfxBase *GfxBase)
68 {
69 struct rgbpix_render_data *prd;
70
71 prd = (struct rgbpix_render_data *)pr_data;
72
73 HIDD_BM_PutPixel(bm, x, y, prd->pixel);
74
75 return 0;
76 }
77 #if 0
78 OOP_AttrBase HiddBitMapAttrBase = 0;
79 OOP_AttrBase HiddGCAttrBase = 0;
80 OOP_AttrBase HiddSyncAttrBase = 0;
81 OOP_AttrBase HiddPixFmtAttrBase = 0;
82 OOP_AttrBase HiddPlanarBMAttrBase = 0;
83 OOP_AttrBase HiddGfxAttrBase = 0;
84 OOP_AttrBase HiddFakeGfxHiddAttrBase = 0;
85
86 static struct OOP_ABDescr attrbases[] = {
87 { IID_Hidd_BitMap, &HiddBitMapAttrBase },
88 { IID_Hidd_GC, &HiddGCAttrBase },
89 { IID_Hidd_Sync, &HiddSyncAttrBase },
90 { IID_Hidd_PixFmt, &HiddPixFmtAttrBase },
91 { IID_Hidd_PlanarBM, &HiddPlanarBMAttrBase },
92 { IID_Hidd_Gfx, &HiddGfxAttrBase },
93 { IID_Hidd_FakeGfxHidd, &HiddFakeGfxHiddAttrBase },
94 { NULL, 0UL }
95 };
96
97 #endif
98
99
100 struct ETextFont
101 {
102 struct TextFont etf_Font;
103 };
104
105
106 /* InitDriverData() just allocates memory for the struct. To use e.g. */
107 /* AreaPtrns, UpdateAreaPtrn() has to allocate the memory for the */
108 /* Pattern itself (and free previously used memory!) */
109
110 #if NEW_DRIVERDATA_CODE
111
112 static inline LONG CalcDriverDataHash(APTR resource)
113 {
114 LONG l1, l2, l3, l4, hash;
115
116 /* FIXME: Probably sucks. I have no clue about this hash stuff */
117
118 l1 = ((LONG)resource) & 0xFF;
119 l2 = (((LONG)resource) >> 8) & 0xFF;
120 l3 = (((LONG)resource) >> 16) & 0xFF;
121 l4 = (((LONG)resource) >> 24) & 0xFF;
122
123 hash = (l1 + l2 + l3 + l4) % DRIVERDATALIST_HASHSIZE;
124
125 return hash;
126 }
127
128 static inline void AddDriverDataToList(struct gfx_driverdata *dd, struct GfxBase * GfxBase)
129 {
130 LONG hash;
131
132 hash = CalcDriverDataHash(dd);
133
134 // ObtainSemaphore(&PrivGBase(GfxBase)->driverdatasem);
135 AddTail((struct List *)&PrivGBase(GfxBase)->driverdatalist[hash], (struct Node *)&dd->dd_Node);
136 // ReleaseSemaphore(&PrivGBase(GfxBase)->driverdatasem);
137
138 }
139
140 static inline void RemoveDriverDataFromList(struct gfx_driverdata *dd, struct GfxBase *GfxBase)
141 {
142 // ObtainSemaphore(&PrivGBase(GfxBase)->driverdatasem);
143 Remove((struct Node *)&dd->dd_Node);
144 // ReleaseSemaphore(&PrivGBase(GfxBase)->driverdatasem);
145 }
146
147 static inline BOOL FindDriverData(struct gfx_driverdata *dd, struct RastPort *rp, struct GfxBase *GfxBase)
148 {
149 struct gfx_driverdata *hn = NULL;
150 LONG hash;
151 BOOL retval = FALSE;
152
153 hash = CalcDriverDataHash(dd);
154
155 // ObtainSemaphore(&PrivGBase(GfxBase)->driverdatasem);
156 ForeachNode((struct List *)&PrivGBase(GfxBase)->driverdatalist[hash], hn)
157 {
158 if ((hn == dd) && (hn->dd_RastPort == rp))
159 {
160 retval = TRUE;
161 break;
162 }
163 }
164 // ReleaseSemaphore(&PrivGBase(GfxBase)->driverdatasem);
165
166 return retval;
167 }
168
169 BOOL ObtainDriverData(struct RastPort *rp, struct GfxBase *GfxBase)
170 {
171 struct gfx_driverdata *dd;
172
173 if (RP_BACKPOINTER(rp) == rp)
174 {
175 if (rp->Flags & RPF_SELF_CLEANUP)
176 {
177 if (RP_DRIVERDATA(rp)) return TRUE;
178 }
179 }
180 else
181 {
182 /* We have detected a manually cloned rastport. Mark it as 'valid'
183 (backpointer to itself) but with NULL driverdata and non-self
184 cleanup */
185 RP_DRIVERDATA(rp) = NULL;
186 rp->Flags &= ~RPF_SELF_CLEANUP;
187 RP_BACKPOINTER(rp) = rp;
188 }
189
190 ObtainSemaphore(&PrivGBase(GfxBase)->driverdatasem);
191 dd = RP_DRIVERDATA(rp);
192 if (dd)
193 {
194 if (!(rp->Flags & RPF_SELF_CLEANUP) && FindDriverData(dd, rp, GfxBase))
195 {
196 dd->dd_LockCount++;
197 }
198 else
199 {
200 RP_DRIVERDATA(rp) = NULL;
201 dd = NULL;
202 }
203 }
204
205 if (!dd)
206 {
207 dd = AllocPooled(PrivGBase(GfxBase)->driverdatapool, sizeof(*dd));
208 if (dd)
209 {
210 struct shared_driverdata *sdd;
211 struct TagItem gc_tags[] = {{ TAG_DONE}};
212
213 sdd = SDD(GfxBase);
214
215 dd->dd_GC = HIDD_Gfx_NewGC(sdd->gfxhidd, gc_tags);
216 if (dd->dd_GC)
217 {
218 dd->dd_RastPort = rp;
219 dd->dd_LockCount = 1;
220
221 RP_DRIVERDATA(rp) = dd;
222 rp->Flags |= RPF_DRIVER_INITED;
223
224 if (!(rp->Flags & RPF_SELF_CLEANUP)) AddDriverDataToList(dd, GfxBase);
225
226 if (rp->BitMap) SetABPenDrMd(rp, (UBYTE)rp->FgPen, (UBYTE)rp->BgPen, rp->DrawMode);
227 }
228 else
229 {
230 FreePooled(PrivGBase(GfxBase)->driverdatapool, dd, sizeof(*dd));
231 dd = NULL;
232 }
233
234 } /* if (dd) */
235
236 } /* if (!dd) */
237
238 ReleaseSemaphore(&PrivGBase(GfxBase)->driverdatasem);
239
240 return dd ? TRUE : FALSE;
241 }
242
243 void ReleaseDriverData(struct RastPort *rp, struct GfxBase *GfxBase)
244 {
245 struct gfx_driverdata *dd = GetDriverData(rp);
246
247 if (!(rp->Flags & RPF_SELF_CLEANUP))
248 {
249 /* FIXME: stegerg 23 jan 2004: needs semprotection, too! */
250 /* CHECKME: stegerg 23 feb 2005: really?? */
251
252 dd->dd_LockCount--;
253
254 // Don't do this:
255 //
256 // if (!dd->dd_LockCount) KillDriverData(rp, GfxBase);
257 //
258 // some garbage collection should later hunt for dd's with
259 // 0 lockcount and possibly non-usage for a certain amount
260 // of time and get rid of them.
261 }
262 }
263
264 void KillDriverData(struct RastPort *rp, struct GfxBase *GfxBase)
265 {
266 if (RP_BACKPOINTER(rp) == rp)
267 {
268 struct gfx_driverdata *dd = NULL;
269
270 if (rp->Flags & RPF_SELF_CLEANUP)
271 {
272 dd = RP_DRIVERDATA(rp);
273 }
274 else
275 {
276 ObtainSemaphore(&PrivGBase(GfxBase)->driverdatasem);
277 if (FindDriverData(RP_DRIVERDATA(rp), rp, GfxBase))
278 {
279 dd = RP_DRIVERDATA(rp);
280 RemoveDriverDataFromList(dd, GfxBase);
281 }
282 ReleaseSemaphore(&PrivGBase(GfxBase)->driverdatasem);
283 }
284
285 if (dd)
286 {
287 struct shared_driverdata *sdd;
288
289 sdd = SDD(GfxBase);
290
291 HIDD_Gfx_DisposeGC(sdd->gfxhidd, dd->dd_GC);
292 FreePooled(PrivGBase(GfxBase)->driverdatapool, dd, sizeof(*dd));
293 RP_DRIVERDATA(rp) = NULL;
294 }
295
296 }
297
298 }
299
300 #else
301
302 struct gfx_driverdata * obsolete_InitDriverData (struct RastPort * rp, struct GfxBase * GfxBase)
303 {
304 struct gfx_driverdata * dd;
305 EnterFunc(bug("InitDriverData(rp=%p)\n", rp));
306
307 /* Does this rastport have a bitmap ? */
308 //if (rp->BitMap)
309 {
310 D(bug("Got bitmap\n"));
311 /* Displayable ? (== rastport of a screen) */
312 //if (IS_HIDD_BM(rp->BitMap))
313 {
314 D(bug("Has HIDD bitmap (displayable)\n"));
315
316 /* We can use this rastport. Allocate driverdata */
317 dd = AllocMem (sizeof(struct gfx_driverdata), MEMF_CLEAR);
318 if (dd)
319 {
320 struct shared_driverdata *sdd;
321 struct TagItem gc_tags[] = {
322 { TAG_DONE, 0UL}
323 };
324
325
326 D(bug("Got driverdata\n"));
327 sdd = SDD(GfxBase);
328
329 dd->dd_GC = HIDD_Gfx_NewGC(sdd->gfxhidd, gc_tags);
330 if (dd->dd_GC)
331 {
332
333 D(bug("Got GC HIDD object\n"));
334 dd->dd_RastPort = rp;
335 SetDriverData(rp, dd);
336 rp->Flags |= RPF_DRIVER_INITED;
337
338 ReturnPtr("InitDriverData", struct gfx_driverdata *, dd);
339 }
340
341 FreeMem(dd, sizeof (struct gfx_driverdata));
342
343 }
344 }
345 }
346
347 ReturnPtr("InitDriverData", struct gfx_driverdata *, NULL);
348 }
349
350 void obsolete_DeinitDriverData (struct RastPort * rp, struct GfxBase * GfxBase)
351 {
352 struct gfx_driverdata * dd;
353 struct shared_driverdata *sdd;
354
355 EnterFunc(bug("DeInitDriverData(rp=%p)\n", rp));
356
357 sdd = SDD(GfxBase);
358
359 dd = RP_DRIVERDATA(rp);;
360 RP_DRIVERDATA(rp) = 0;
361
362 HIDD_Gfx_DisposeGC(sdd->gfxhidd, dd->dd_GC);
363
364 FreeMem (dd, sizeof(struct gfx_driverdata));
365 rp->Flags &= ~RPF_DRIVER_INITED;
366
367 ReturnVoid("DeinitDriverData");
368 }
369
370 BOOL obsolete_CorrectDriverData (struct RastPort * rp, struct GfxBase * GfxBase)
371 {
372 BOOL retval = TRUE;
373 struct gfx_driverdata * dd, * old;
374
375 if (!rp)
376 {
377 retval = FALSE;
378 }
379 else
380 {
381 old = GetDriverData(rp);
382 if (!old)
383 {
384 old = obsolete_InitDriverData(rp, GfxBase);
385
386 /* stegerg: ???? would have returned TRUE even if old == NULL
387 if (old)
388 retval = TRUE;
389 */
390 if (!old) retval = FALSE;
391 }
392 else if (rp != old->dd_RastPort)
393 {
394 /* stegerg: cloned rastport?
395 ** Make sure to clear driverdata pointer and flag
396 ** in case InitDriverData fail
397 */
398 RP_DRIVERDATA(rp) = 0;
399 rp->Flags &= ~RPF_DRIVER_INITED;
400
401 dd = obsolete_InitDriverData(rp, GfxBase);
402
403 /* stegerg: ???? would have returned TRUE even if dd = NULL
404 if (dd)
405 retval = TRUE;
406 */
407
408 if (!dd) retval = FALSE;
409
410 }
411 }
412
413 return retval;
414 }
415
416 #endif
417
418 int driver_init(struct GfxBase * GfxBase)
419 {
420
421 EnterFunc(bug("driver_init()\n"));
422
423 /* Initialize the semaphore used for the chunky buffer */
424 InitSemaphore(&(PrivGBase(GfxBase)->pixbuf_sema));
425 InitSemaphore(&(PrivGBase(GfxBase)->blit_sema));
426
427 /* Init the needed attrbases */
428
429 __IHidd_BitMap = OOP_ObtainAttrBase(IID_Hidd_BitMap);
430 __IHidd_GC = OOP_ObtainAttrBase(IID_Hidd_GC);
431 __IHidd_Sync = OOP_ObtainAttrBase(IID_Hidd_Sync);
432 __IHidd_PixFmt = OOP_ObtainAttrBase(IID_Hidd_PixFmt);
433 __IHidd_PlanarBM = OOP_ObtainAttrBase(IID_Hidd_PlanarBM);
434 __IHidd_Gfx = OOP_ObtainAttrBase(IID_Hidd_Gfx);
435 __IHidd_FakeGfxHidd = OOP_ObtainAttrBase(IID_Hidd_FakeGfxHidd);
436
437
438 if (__IHidd_BitMap &&
439 __IHidd_GC &&
440 __IHidd_Sync &&
441 __IHidd_PixFmt &&
442 __IHidd_PlanarBM &&
443 __IHidd_Gfx &&
444 __IHidd_FakeGfxHidd)
445 {
446 PrivGBase(GfxBase)->pixel_buf=AllocMem(PIXELBUF_SIZE,MEMF_ANY);
447 if (PrivGBase(GfxBase)->pixel_buf) {
448
449 ReturnInt("driver_init", int, TRUE);
450
451 FreeMem(PrivGBase(GfxBase)->pixel_buf, PIXELBUF_SIZE);
452 }
453
454 }
455
456 ReturnInt("driver_init", int, FALSE);
457 }
458
459 int driver_open (struct GfxBase * GfxBase)
460 {
461 return TRUE;
462 }
463
464 void driver_close (struct GfxBase * GfxBase)
465 {
466 return;
467 }
468
469 void driver_expunge (struct GfxBase * GfxBase)
470 {
471
472 /* Try to free some other stuff */
473 cleanup_cursor(GfxBase);
474
475 if (SDD(GfxBase)->framebuffer)
476 OOP_DisposeObject(SDD(GfxBase)->framebuffer);
477
478 #if 0
479 if (SDD(GfxBase)->activescreen_inited)
480 cleanup_activescreen_stuff(GfxBase);
481 #endif
482 if (SDD(GfxBase)->dispinfo_db)
483 destroy_dispinfo_db(SDD(GfxBase)->dispinfo_db, GfxBase);
484
485 if ( SDD(GfxBase)->planarbm_cache )
486 delete_object_cache( SDD(GfxBase)->planarbm_cache, GfxBase );
487
488 if ( SDD(GfxBase)->gc_cache )
489 delete_object_cache( SDD(GfxBase)->gc_cache, GfxBase );
490
491 if ( SDD(GfxBase)->fakegfx_inited )
492 cleanup_fakegfxhidd( &SDD(GfxBase)->fakegfx_staticdata, GfxBase);
493
494 if ( SDD(GfxBase)->gfxhidd_orig )
495 OOP_DisposeObject( SDD(GfxBase)->gfxhidd_orig );
496
497 return;
498 }
499
500 /* Called after DOS is up & running */
501 static OOP_Object *create_framebuffer(struct GfxBase *GfxBase)
502 {
503 struct TagItem fbtags[] = {
504 { aHidd_BitMap_FrameBuffer, TRUE },
505 { aHidd_BitMap_ModeID, 0 },
506 { TAG_DONE, 0 }
507 };
508
509 HIDDT_ModeID hiddmode;
510 OOP_Object *fb = NULL;
511
512 /* Get the highest available resolution at the best possible depth */
513 hiddmode = get_best_resolution_and_depth(GfxBase);
514 if (vHidd_ModeID_Invalid == hiddmode) {
515 D(bug("!!! create_framebuffer(): COULD NOT GET HIDD MODEID !!!\n"));
516 } else {
517 /* Create the framebuffer object */
518 fbtags[1].ti_Data = hiddmode;
519 fb = HIDD_Gfx_NewBitMap(SDD(GfxBase)->gfxhidd, fbtags);
520 }
521
522 return fb;
523 }
524 const UBYTE def_pointer_shape[] =
525 {
526 06,02,00,00,00,00,00,00,00,00,00,
527 01,06,02,02,00,00,00,00,00,00,00,
528 00,01,06,06,02,02,00,00,00,00,00,
529 00,01,06,06,06,06,02,02,00,00,00,
530 00,00,01,06,06,06,06,06,02,02,00,
531 00,00,01,06,06,06,06,06,06,06,00,
532 00,00,00,01,06,06,06,02,00,00,00,
533 00,00,00,01,06,06,01,06,02,00,00,
534 00,00,00,00,01,06,00,01,06,02,00,
535 00,00,00,00,01,06,00,00,01,06,02,
536 00,00,00,00,00,00,00,00,00,01,06
537 };
538
539 #define DEF_POINTER_WIDTH 11
540 #define DEF_POINTER_HEIGHT 11
541 #define DEF_POINTER_DEPTH 7
542
543
544 static BOOL init_cursor(struct GfxBase *GfxBase)
545 {
546 /* Create the pointer bitmap */
547 struct TagItem pbmtags[] = {
548 { aHidd_BitMap_Width, DEF_POINTER_WIDTH },
549 { aHidd_BitMap_Height, DEF_POINTER_HEIGHT },
550 { aHidd_BitMap_StdPixFmt, vHidd_StdPixFmt_LUT8 },
551 { TAG_DONE, 0UL }
552 };
553 SDD(GfxBase)->pointerbm = HIDD_Gfx_NewBitMap(SDD(GfxBase)->gfxhidd, pbmtags);
554 if (NULL != SDD(GfxBase)->pointerbm) {
555 OOP_Object *gc;
556
557 gc = obtain_cache_object(SDD(GfxBase)->gc_cache, GfxBase);
558 if (NULL != gc) {
559 /* Copy the default pointer image into the created pointer bitmap */
560 ULONG i;
561 struct TagItem gc_tags[] = {
562 { aHidd_GC_DrawMode, vHidd_GC_DrawMode_Copy },
563 { TAG_DONE, 0UL }
564 };
565
566 HIDDT_Color col[DEF_POINTER_DEPTH];
567
568 col[0].red = 0x0000;
569 col[0].green = 0x0000;
570 col[0].blue = 0x0000;
571 col[0].alpha = 0x0000;
572 col[1].red = 0x0000;
573 col[1].green = 0x0000;
574 col[1].blue = 0x1200;
575 col[1].alpha = 0x0000;
576 col[2].red = 0xE0E0;
577 col[2].green = 0xE0E0;
578 col[2].blue = 0xC0C0;
579 col[2].alpha = 0x0000;
580 col[6].red = 0xE0E0;
581 col[6].green = 0x4040;
582 col[6].blue = 0x4040;
583 col[6].alpha = 0x0000;
584
585 for (i = 3; i < 6; i ++) {
586 col[i].red = 0x0000;
587 col[i].green = 0x0000;
588 col[i].blue = 0x0000;
589 col[i].alpha = 0x0000;
590 }
591 for (i = 7; i < DEF_POINTER_DEPTH; i ++) {
592 col[i].red = 0x0000;
593 col[i].green = 0x0000;
594 col[i].blue = 0x0000;
595 col[i].alpha = 0x0000;
596 }
597
598 HIDD_BM_SetColors(SDD(GfxBase)->pointerbm, col, 0, DEF_POINTER_DEPTH);
599
600 OOP_SetAttrs(gc, gc_tags);
601 #if 0
602 /* PutImageLUT not yet implemented in gfx baseclass */
603 HIDD_BM_PutImageLUT(SDD(GfxBase)->pointerbm, gc
604 , (UBYTE *)def_pointer_shape
605 , DEF_POINTER_WIDTH
606 , 0, 0
607 , DEF_POINTER_WIDTH, DEF_POINTER_HEIGHT
608 , &plut
609 );
610 #else
611 HIDD_BM_PutImage(SDD(GfxBase)->pointerbm, gc
612 , (UBYTE *)def_pointer_shape
613 , DEF_POINTER_WIDTH
614 , 0, 0
615 , DEF_POINTER_WIDTH, DEF_POINTER_HEIGHT
616 , vHidd_StdPixFmt_LUT8
617 );
618
619 #endif
620 release_cache_object(SDD(GfxBase)->gc_cache, gc, GfxBase);
621
622 if (HIDD_Gfx_SetCursorShape(SDD(GfxBase)->gfxhidd, SDD(GfxBase)->pointerbm)) {
623 D(bug("CURSOR SHAPE SET\n"));
624 /* Make it visible */
625 HIDD_Gfx_SetCursorVisible(SDD(GfxBase)->gfxhidd, TRUE);
626
627 return TRUE;
628 }
629 }
630 }
631
632 cleanup_cursor(GfxBase);
633
634 return FALSE;
635 }
636
637 static VOID cleanup_cursor(struct GfxBase *GfxBase)
638 {
639 if (NULL != SDD(GfxBase)->pointerbm) {
640 OOP_DisposeObject(SDD(GfxBase)->pointerbm);
641 SDD(GfxBase)->pointerbm = NULL;
642 }
643 }
644
645 BOOL driver_LateGfxInit (APTR data, struct GfxBase *GfxBase)
646 {
647
648 /* Supplied data is really the librarybase of a HIDD */
649 STRPTR gfxhiddname = (STRPTR)data;
650 struct TagItem tags[] = {
651 { TAG_DONE, 0UL },
652 };
653 EnterFunc(bug("driver_LateGfxInit(gfxhiddname=%s)\n", gfxhiddname));
654
655 /* Create a new GfxHidd object */
656
657 SDD(GfxBase)->gfxhidd = SDD(GfxBase)->gfxhidd_orig = OOP_NewObject(NULL, gfxhiddname, tags);
658 D(bug("driver_LateGfxInit: gfxhidd=%p\n", SDD(GfxBase)->gfxhidd));
659
660 if (NULL != SDD(GfxBase)->gfxhidd) {
661 IPTR hwcursor;
662 BOOL ok = TRUE;
663
664 /* Get method id here, to avoid any possible semaphore involment when calling the method */
665 SDD(GfxBase)->hiddGfxShowImminentReset_MethodID = OOP_GetMethodID(IID_Hidd_Gfx, moHidd_Gfx_ShowImminentReset);
666
667 OOP_GetAttr(SDD(GfxBase)->gfxhidd, aHidd_Gfx_SupportsHWCursor, &hwcursor);
668 SDD(GfxBase)->has_hw_cursor = (BOOL)hwcursor;
669 if (!hwcursor) {
670 OOP_Object *fgh;
671 D(bug("There's no hardware cursor\n"));
672
673 fgh = init_fakegfxhidd(SDD(GfxBase)->gfxhidd
674 , &SDD(GfxBase)->fakegfx_staticdata
675 , GfxBase);
676
677 if (NULL != fgh) {
678 SDD(GfxBase)->gfxhidd = fgh;
679 SDD(GfxBase)->fakegfx_inited = TRUE;
680 } else {
681 ok = FALSE;
682 }
683 }
684
685 if (ok) {
686 struct TagItem gc_create_tags[] = { { TAG_DONE, 0UL } };
687 D(bug("Ok\n"));
688 SDD(GfxBase)->gc_cache = create_object_cache(NULL, IID_Hidd_GC, gc_create_tags, GfxBase);
689 if (NULL != SDD(GfxBase)->gc_cache) {
690
691 struct TagItem bm_create_tags[] = {
692 #warning Maybe make this class private and create the object through the graphicshidd
693 { aHidd_BitMap_GfxHidd, (IPTR)SDD(GfxBase)->gfxhidd_orig },
694 { aHidd_BitMap_Displayable, FALSE },
695 { aHidd_PlanarBM_AllocPlanes, FALSE },
696 { TAG_DONE, 0UL }
697 };
698
699 D(bug("Cache created\n"));
700 SDD(GfxBase)->planarbm_cache = create_object_cache(NULL, CLID_Hidd_PlanarBM, bm_create_tags, GfxBase);
701
702 if (NULL != SDD(GfxBase)->planarbm_cache) {
703
704 /* Move the modes into the displayinfo DB */
705 SDD(GfxBase)->dispinfo_db = build_dispinfo_db(GfxBase);
706 if (NULL != SDD(GfxBase)->dispinfo_db) {
707
708 SDD(GfxBase)->framebuffer = create_framebuffer(GfxBase);
709 if (NULL != SDD(GfxBase)->framebuffer) {
710 D(bug("FRAMEBUFFER OK: %p\n", SDD(GfxBase)->framebuffer));
711 if (init_cursor(GfxBase)) {
712
713 D(bug("MOUSE INITED\n"));
714 ReturnBool("driver_LateGfxInit", TRUE);
715 }
716 OOP_DisposeObject(SDD(GfxBase)->framebuffer);
717 } /* if (framebuffer inited) */
718 destroy_dispinfo_db(SDD(GfxBase)->dispinfo_db, GfxBase);
719 SDD(GfxBase)->dispinfo_db = NULL;
720 } /* if (displayinfo db inited) */
721 delete_object_cache(SDD(GfxBase)->planarbm_cache, GfxBase);
722 SDD(GfxBase)->planarbm_cache = NULL;
723 } /* if (planarbm cache created) */
724 delete_object_cache(SDD(GfxBase)->gc_cache, GfxBase);
725 SDD(GfxBase)->gc_cache = NULL;
726 } /* if (gc object cache ok) */
727
728 } /* if (fake gfx stuff ok) */
729
730 if (SDD(GfxBase)->fakegfx_inited) {
731 cleanup_fakegfxhidd(&SDD(GfxBase)->fakegfx_staticdata, GfxBase);
732 SDD(GfxBase)->fakegfx_inited = FALSE;
733 }
734 OOP_DisposeObject(SDD(GfxBase)->gfxhidd_orig);
735 SDD(GfxBase)->gfxhidd_orig = NULL;
736
737 }
738
739 ReturnBool("driver_LateGfxInit", FALSE);
740
741 }
742
743
744 #if 0 /* Unused? */
745
746 static ULONG getbitmappixel(struct BitMap *bm
747 , LONG x
748 , LONG y
749 , UBYTE depth
750 , UBYTE plane_mask)
751 {
752 UBYTE i;
753 ULONG idx;
754
755 ULONG mask;
756 ULONG pen = 0L;
757
758 idx = COORD_TO_BYTEIDX(x, y, bm->BytesPerRow);
759 mask = XCOORD_TO_MASK( x );
760
761 for (i = depth - 1; depth; i -- , depth -- )
762 {
763 pen <<= 1; /* stegerg: moved to here, was inside if!? */
764
765 if ((1L << i) & plane_mask)
766 {
767 UBYTE *plane = bm->Planes[i];
768
769 if (plane == (PLANEPTR)-1)
770 {
771 pen |= 1;
772 }
773 else if (plane != NULL)
774 {
775 if ((plane[idx] & mask) != 0)
776 pen |= 1;
777 }
778 }
779
780 }
781 return pen;
782 }
783
784 #endif
785
786
787 #define dumprect(rect) \
788 kprintf(#rect " : (%d,%d) - (%d,%d)\n",(rect)->MinX,(rect)->MinY,(rect)->MaxX,(rect)->MaxY)
789
790
791 struct bgf_render_data {
792 WORD fbm_xsrc;
793 OOP_Object *fbm;
794 };
795
796 static ULONG bgf_render(APTR bgfr_data
797 , LONG srcx, LONG srcy
798 , OOP_Object *dstbm_obj, OOP_Object *dst_gc
799 , LONG x1, LONG y1, LONG x2, LONG y2
800 , struct GfxBase *GfxBase)
801 {
802 struct bgf_render_data *bgfrd;
803 ULONG width, height;
804
805 width = x2 - x1 + 1;
806 height = y2 - y1 + 1;
807
808 ASSERT(width > 0 && height > 0);
809
810 bgfrd = (struct bgf_render_data *)bgfr_data;
811
812 HIDD_BM_BlitColorExpansion( dstbm_obj
813 , dst_gc
814 , bgfrd->fbm
815 , srcx + bgfrd->fbm_xsrc, srcy /* stegerg: instead of srcy there was a 0 */
816 , x1, y1
817 , width, height
818 );
819
820 return width * height;
821
822 }
823
824 void blit_glyph_fast(struct RastPort *rp, OOP_Object *fontbm, WORD xsrc
825 , WORD destx, WORD desty, UWORD width, UWORD height
826 , struct GfxBase * GfxBase)
827 {
828
829 struct Rectangle rr;
830 struct bgf_render_data bgfrd;
831
832 EnterFunc(bug("blit_glyph_fast(%d, %d, %d, %d, %d)\n"
833 , xsrc, destx, desty, width, height));
834
835
836 ASSERT(width > 0 && height > 0);
837
838 bgfrd.fbm_xsrc = xsrc;
839 bgfrd.fbm = fontbm;
840
841 rr.MinX = destx;
842 rr.MinY = desty;
843 rr.MaxX = destx + width - 1;
844 rr.MaxY = desty + height - 1;
845
846 if (!OBTAIN_DRIVERDATA(rp, GfxBase))
847 ReturnVoid("blit_glyph_fast");
848
849 do_render_func(rp, NULL, &rr, bgf_render, &bgfrd, FALSE, GfxBase);
850
851 RELEASE_DRIVERDATA(rp, GfxBase);
852
853 ReturnVoid("blit_glyph_fast");
854 }
855
856
857
858 #define NUMCHARS(tf) ((tf->tf_HiChar - tf->tf_LoChar) + 2)
859 #define CTF(x) ((struct ColorTextFont *)x)
860
861 void driver_Text (struct RastPort * rp, CONST_STRPTR string, LONG len,
862 struct GfxBase * GfxBase)
863 {
864
865 #warning Does not handle color textfonts
866 WORD render_y;
867 struct TextFont *tf;
868 WORD current_x;
869 OOP_Object *fontbm = NULL;
870
871 if (!OBTAIN_DRIVERDATA(rp, GfxBase))
872 return;
873
874 if ((rp->DrawMode & ~INVERSVID) == JAM2)
875 {
876 struct TextExtent te;
877 ULONG old_drmd = GetDrMd(rp);
878
879 /* This is actually needed, because below only the
880 part of the glyph which contains data is rendered:
881
882 ...1100...
883 ...1100...
884 ...1100...
885 ...1111...
886
887 '.' at left side can be there because of kerning.
888 '.' at the right side can be there because of
889 CharSpace being bigger than glyph bitmap data
890 width.
891 */
892
893 TextExtent(rp, string, len, &te);
894 SetDrMd(rp, old_drmd ^ INVERSVID);
895 RectFill(rp, rp->cp_x + te.te_Extent.MinX,
896 rp->cp_y + te.te_Extent.MinY,
897 rp->cp_x + te.te_Extent.MaxX,
898 rp->cp_y + te.te_Extent.MaxY);
899 SetDrMd(rp, old_drmd);
900 }
901
902 /* does this rastport have a layer. If yes, lock the layer it.*/
903 if (NULL != rp->Layer)
904 LockLayerRom(rp->Layer);
905
906 tf = rp->Font;
907
908 if (ExtendFont(tf, NULL))
909 {
910 fontbm = TFE_INTERN(tf->tf_Extension)->hash->font_bitmap;
911 }
912
913 /* Check if font has character data as a HIDD bitmap */
914
915 if (NULL == fontbm)
916 {
917 D(bug("FONT HAS NO HIDD BITMAP ! Won't render text\n"));
918 RELEASE_DRIVERDATA(rp, GfxBase);
919 return;
920 }
921
922
923 /* Render along font's baseline */
924 render_y = rp->cp_y - tf->tf_Baseline;
925 current_x = rp->cp_x;
926
927 while ( len -- )
928 {
929 ULONG charloc;
930 ULONG idx;
931
932 if (*string < tf->tf_LoChar || *string > tf->tf_HiChar )
933 {
934 /* A character which there is no glyph for. We just
935 draw the last glyph in the font
936 */
937 idx = NUMCHARS(tf) - 1;
938 }
939 else
940 {
941 idx = *string - tf->tf_LoChar;
942 }
943
944 charloc = ((ULONG *)tf->tf_CharLoc)[idx];
945
946 if (tf->tf_CharKern)
947 {
948 current_x += ((WORD *)tf->tf_CharKern)[idx];
949 }
950
951 if ((tf->tf_Style & FSF_COLORFONT) &&
952 !(CTF(tf)->ctf_Flags & CT_ANTIALIAS))
953 {
954 #warning Handle color fonts
955 }
956 else
957 {
958 WORD
959 glyphXOffset = charloc >> 16,
960 glyphWidth = charloc & 0xFFFF;
961
962 ASSERT(tf->tf_YSize > 0);
963
964 /* blit the glypth if it has data in the bitmap */
965 if (glyphWidth > 0)
966 {
967 blit_glyph_fast(rp, fontbm, glyphXOffset, current_x, render_y,
968 glyphWidth, tf->tf_YSize, GfxBase);
969 }
970 }
971
972 if (tf->tf_CharSpace)
973 current_x += ((WORD *)tf->tf_CharSpace)[idx];
974 else
975 current_x += tf->tf_XSize; /* Add glyph width */
976
977 current_x += rp->TxSpacing;
978
979 string ++;
980 } /* for (each character to render) */
981
982 Move(rp, current_x, rp->cp_y);
983
984 if (NULL != rp->Layer)
985 UnlockLayerRom(rp->Layer);
986
987 RELEASE_DRIVERDATA(rp, GfxBase);
988
989 return;
990
991 }
992
993 /***********************************************/
994 /* CYBERGFX CALLS ***/
995
996
997 struct wpa_render_data
998 {
999 UBYTE *array;
1000 HIDDT_StdPixFmt pixfmt;
1001 ULONG modulo;
1002 ULONG bppix;
1003 };
1004
1005 static ULONG wpa_render(APTR wpar_data
1006 , LONG srcx, LONG srcy
1007 , OOP_Object *dstbm_obj
1008 , OOP_Object *dst_gc
1009 , LONG x1, LONG y1, LONG x2, LONG y2
1010 , struct GfxBase *GfxBase)
1011 {
1012 struct wpa_render_data *wpard;
1013 ULONG width, height;
1014 UBYTE *array;
1015
1016 width = x2 - x1 + 1;
1017 height = y2 - y1 + 1;
1018
1019 wpard = (struct wpa_render_data *)wpar_data;
1020
1021 array = wpard->array + wpard->modulo * srcy + wpard->bppix * srcx;
1022
1023 HIDD_BM_PutImage(dstbm_obj
1024 , dst_gc, array
1025 , wpard->modulo
1026 , x1, y1
1027 , width, height
1028 , wpard->pixfmt
1029 );
1030
1031 return width * height;
1032 }
1033
1034 struct wpaa_render_data
1035 {
1036 UBYTE *array;
1037 ULONG modulo;
1038 };
1039
1040 static ULONG wpaa_render(APTR wpaar_data
1041 , LONG srcx, LONG srcy
1042 , OOP_Object *dstbm_obj
1043 , OOP_Object *dst_gc
1044 , LONG x1, LONG y1, LONG x2, LONG y2
1045 , struct GfxBase *GfxBase)
1046 {
1047 struct wpaa_render_data *wpaard;
1048 ULONG width, height;
1049 UBYTE *array;
1050
1051 width = x2 - x1 + 1;
1052 height = y2 - y1 + 1;
1053
1054 wpaard = (struct wpaa_render_data *)wpaar_data;
1055
1056 array = wpaard->array + wpaard->modulo * srcy + 4 * srcx;
1057
1058 HIDD_BM_PutAlphaImage(dstbm_obj
1059 , dst_gc, array
1060 , wpaard->modulo
1061 , x1, y1
1062 , width, height
1063 );
1064
1065 return width * height;
1066 }
1067
1068 struct bta_render_data
1069 {
1070 UBYTE *array;
1071 ULONG modulo;
1072 UBYTE invertalpha;
1073 };
1074
1075 static ULONG bta_render(APTR bta_data
1076 , LONG srcx, LONG srcy
1077 , OOP_Object *dstbm_obj
1078 , OOP_Object *dst_gc
1079 , LONG x1, LONG y1, LONG x2, LONG y2
1080 , struct GfxBase *GfxBase)
1081 {
1082 struct bta_render_data *btard;
1083 ULONG width, height;
1084 UBYTE *array;
1085
1086 width = x2 - x1 + 1;
1087 height = y2 - y1 + 1;
1088
1089 btard = (struct bta_render_data *)bta_data;
1090
1091 array = btard->array + btard->modulo * srcy + srcx;
1092
1093 HIDD_BM_PutAlphaTemplate(dstbm_obj
1094 , dst_gc, array
1095 , btard->modulo
1096 , x1, y1
1097 , width, height
1098 , btard->invertalpha
1099 );
1100
1101 return width * height;
1102 }
1103
1104 struct rpa_render_data {
1105 UBYTE *array;
1106 HIDDT_StdPixFmt pixfmt;
1107 ULONG modulo;
1108 ULONG bppix;
1109 };
1110
1111 static ULONG rpa_render(APTR rpar_data
1112 , LONG srcx, LONG srcy
1113 , OOP_Object *dstbm_obj
1114 , OOP_Object *dst_gc
1115 , LONG x1, LONG y1, LONG x2, LONG y2
1116 , struct GfxBase *GfxBase)
1117 {
1118 struct rpa_render_data *rpard;
1119 ULONG width, height;
1120 UBYTE *array;
1121
1122 width = x2 - x1 + 1;
1123 height = y2 - y1 + 1;
1124
1125 rpard = (struct rpa_render_data *)rpar_data;
1126
1127 array = rpard->array + rpard->modulo * srcy + rpard->bppix * srcx;
1128
1129 HIDD_BM_GetImage(dstbm_obj
1130 , array
1131 , rpard->modulo
1132 , x1, y1
1133 , width, height
1134 , rpard->pixfmt
1135 );
1136
1137 return width * height;
1138 }
1139
1140 static LONG pix_read(APTR pr_data
1141 , OOP_Object *bm, OOP_Object *gc
1142 , LONG x, LONG y
1143 , struct GfxBase *GfxBase)
1144 {
1145 struct rgbpix_render_data *prd;
1146
1147 prd = (struct rgbpix_render_data *)pr_data;
1148
1149 prd->pixel = HIDD_BM_GetPixel(bm, x, y);
1150
1151
1152 return 0;
1153 }
1154
1155
1156 struct extcol_render_data {
1157 struct render_special_info rsi;
1158 struct BitMap *destbm;
1159 HIDDT_Pixel pixel;
1160
1161 };
1162
1163 static VOID buf_to_extcol(struct extcol_render_data *ecrd
1164 , LONG srcx, LONG srcy
1165 , LONG dstx, LONG dsty
1166 , ULONG width, ULONG height
1167 , HIDDT_Pixel *pixbuf
1168 , OOP_Object *bm_obj
1169 , HIDDT_Pixel *pixtab)
1170 {
1171 LONG y;
1172 struct BitMap *bm;
1173 bm = ecrd->destbm;
1174 for (y = 0; y < height; y ++) {
1175 LONG x;
1176
1177 for (x = 0; x < width; x ++) {
1178 if (*pixbuf ++ == ecrd->pixel) {
1179
1180 UBYTE *plane;
1181 ULONG i;
1182 /* Set the according bit in the bitmap */
1183 for (i = 0; i < bm->Depth; i ++) {
1184 plane = bm->Planes[i];
1185 if (NULL != plane) {
1186 UBYTE mask;
1187
1188 plane += COORD_TO_BYTEIDX(x + dstx, y + dsty, bm->BytesPerRow);
1189 mask = XCOORD_TO_MASK(x + dstx);
1190
1191 /* Set the pixel */
1192 *plane |= mask;
1193
1194 } /* if (plane allocated) */
1195 } /* for (plane) */
1196 } /* if (color match) */
1197 } /* for (x) */
1198 } /* for (y) */
1199
1200 return;
1201 }
1202
1203
1204
1205 static ULONG extcol_render(APTR funcdata
1206 , LONG dstx, LONG dsty
1207 , OOP_Object *dstbm_obj
1208 , OOP_Object *dst_gc
1209 , LONG x1, LONG y1, LONG x2, LONG y2
1210 , struct GfxBase *GfxBase)
1211 {
1212 /* Get the info from the hidd */
1213 struct extcol_render_data *ecrd;
1214
1215 ecrd = (struct extcol_render_data *)funcdata;
1216
1217 hidd2buf_fast(ecrd->rsi.curbm
1218 , x1, y1
1219 , (APTR)ecrd
1220 , dstx, dsty
1221 , x2 - x1 + 1
1222 , y2 - y1 + 1
1223 , buf_to_extcol
1224 , GfxBase
1225 );
1226
1227 return (x2 - x1 + 1) * (y2 - y1 + 1);
1228 }
1229
1230
1231 struct dm_message {
1232 APTR memptr;
1233 ULONG offsetx;
1234 ULONG offsety;
1235 ULONG xsize;
1236 ULONG ysize;
1237 UWORD bytesperrow;
1238 UWORD bytesperpix;
1239 UWORD colormodel;
1240
1241 };
1242
1243 struct dm_render_data {
1244 struct dm_message msg;
1245 OOP_Object *pf;
1246 struct Hook *hook;
1247 struct RastPort *rp;
1248 IPTR stdpf;
1249 OOP_Object *gc;
1250 };
1251
1252
1253 static ULONG dm_render(APTR dmr_data
1254 , LONG srcx, LONG srcy
1255 , OOP_Object *dstbm_obj
1256 , OOP_Object *dst_gc
1257 , LONG x1, LONG y1, LONG x2, LONG y2
1258 , struct GfxBase *GfxBase)
1259 {
1260 struct dm_render_data *dmrd;
1261 UBYTE *addr;
1262 struct dm_message *msg;
1263 IPTR bytesperpixel;
1264 ULONG width, height, fb_width, fb_height;
1265 ULONG banksize, memsize;
1266
1267 dmrd = (struct dm_render_data *)dmr_data;
1268 width = x2 - x1 + 1;
1269 height = y2 - y1 + 1;;
1270 msg = &dmrd->msg;
1271 #if 1
1272 msg->offsetx = x1;
1273 msg->offsety = y1;
1274 #else
1275 #warning "Not sure about this one . Set it to 0 since we adjust msg->memptr to x1/y1 lower down"
1276 msg->offsetx = 0; // x1;
1277 msg->offsety = 0; // y1;
1278 #endif
1279 msg->xsize = width;
1280 msg->ysize = height;
1281
1282 /* Get the baseadress from where to render */
1283 if (HIDD_BM_ObtainDirectAccess(dstbm_obj
1284 , &addr
1285 , &fb_height, &fb_width
1286 , &banksize, &memsize)) {
1287
1288 OOP_GetAttr(dmrd->pf, aHidd_PixFmt_BytesPerPixel, &bytesperpixel);
1289 msg->bytesperpix = (UWORD)bytesperpixel;
1290
1291 /* Colormodel allready set */
1292
1293 /* Compute the adress for the start pixel */
1294 #warning "We should maybe use something else than the BytesPerLine method since we may have alignment"
1295 msg->bytesperrow = HIDD_BM_BytesPerLine(dstbm_obj, dmrd->stdpf, width);
1296 #if 1
1297 msg->memptr = addr;
1298 #else
1299 msg->memptr = addr + (msg->bytesperrow * y1) + (bytesperpixel * x1);
1300 #endif
1301
1302 HIDD_BM_ReleaseDirectAccess(dstbm_obj);
1303
1304 CallHookPkt(dmrd->hook, dmrd->rp, msg);
1305
1306 } else {
1307 /* We are unable to gain direct access to the framebuffer,
1308 so we have to emulate it
1309 */
1310 ULONG bytesperrow;
1311 ULONG tocopy_h, max_tocopy_h;
1312 ULONG lines_todo;
1313
1314 lines_todo = height;
1315
1316 /* The HIDD bm does not have a base adress so we have to render into
1317 it using a temporary buffer
1318 */
1319 OOP_GetAttr(dmrd->pf, aHidd_PixFmt_BytesPerPixel, &bytesperpixel);
1320 //bytesperrow = HIDD_BM_BytesPerLine(dstbm_obj, dmrd->stdpf, width);
1321 bytesperrow = width * bytesperpixel;
1322
1323
1324 kprintf("width %d bytesperrow %d bytesperpixel %d\n", width, bytesperrow, bytesperpixel);
1325 kprintf(" colormodel %d\n", msg->colormodel);
1326
1327 if (PIXELBUF_SIZE < bytesperrow) {
1328 D(bug("!!! NOT ENOUGH SPACE IN TEMP BUFFER FOR A SINGLE LINE IN DoCDrawMethodTagList() !!!\n"));
1329 return 0;
1330 }
1331
1332 /* Calculate number of lines we might copy */
1333 max_tocopy_h = PIXELBUF_SIZE / bytesperrow;
1334
1335 #if 1
1336 msg->offsetx = 0;
1337 msg->offsety = 0;
1338 #endif
1339 /* Get the maximum number of lines */
1340 while (lines_todo != 0) {
1341
1342 struct TagItem gc_tags[] = {
1343 { aHidd_GC_DrawMode, vHidd_GC_DrawMode_Copy },
1344 { TAG_DONE, 0UL }
1345 };
1346
1347 IPTR old_drmd;
1348
1349 tocopy_h = MIN(lines_todo, max_tocopy_h);
1350 msg->memptr = PrivGBase(GfxBase)->pixel_buf;
1351 msg->bytesperrow = bytesperrow;
1352
1353 msg->bytesperpix = (UWORD)bytesperpixel;
1354
1355 LOCK_PIXBUF
1356 HIDD_BM_GetImage(dstbm_obj
1357 , (UBYTE *)PrivGBase(GfxBase)->pixel_buf
1358 , bytesperrow
1359 , x1, y1 + height - lines_todo, width, lines_todo
1360 , dmrd->stdpf
1361 );
1362
1363 /* Use the hook to set some pixels */
1364 CallHookPkt(dmrd->hook, dmrd->rp, msg);
1365
1366 OOP_GetAttr(dmrd->gc, aHidd_GC_DrawMode, &old_drmd);
1367 OOP_SetAttrs(dmrd->gc, gc_tags);
1368 HIDD_BM_PutImage(dstbm_obj, dmrd->gc
1369 , (UBYTE *)PrivGBase(GfxBase)->pixel_buf
1370 , bytesperrow
1371 , x1, y1 + height - lines_todo, width, lines_todo
1372 , dmrd->stdpf
1373 );
1374 gc_tags[0].ti_Data = (IPTR)old_drmd;
1375 OOP_SetAttrs(dmrd->gc, gc_tags);
1376
1377 ULOCK_PIXBUF
1378
1379 lines_todo -= tocopy_h;
1380 }
1381
1382 }
1383
1384 return width * height;
1385 }
1386
1387
1388
1389 LONG driver_WriteLUTPixelArray(APTR srcrect,
1390 UWORD srcx, UWORD srcy,
1391 UWORD srcmod, struct RastPort *rp, APTR ctable,
1392 UWORD destx, UWORD desty,
1393 UWORD sizex, UWORD sizey,
1394 UBYTE ctabformat,
1395 struct GfxBase *GfxBase)
1396 {
1397 ULONG depth;
1398
1399 HIDDT_PixelLUT pixlut;
1400 HIDDT_Pixel pixtab[256];
1401
1402 HIDDT_Color col;
1403 ULONG i;
1404
1405 LONG pixwritten = 0;
1406 UBYTE *buf;
1407
1408 /* This is cybergraphx. We only work wih HIDD bitmaps */
1409 if (!IS_HIDD_BM(rp->BitMap)) {
1410 D(bug("!!!!! Trying to use CGFX call on non-hidd bitmap in WriteLUTPixelArray()!!!\n"));
1411 return 0;
1412 }
1413
1414 pixlut.entries = 256;
1415 pixlut.pixels = pixtab;
1416
1417 depth = GetBitMapAttr(rp->BitMap, BMA_DEPTH);
1418
1419 /* This call does only support bitmaps with depth > 8. Use WritePixelArray8
1420 for other bitmaps
1421 */
1422
1423 if (depth <= 8) {
1424 D(bug("!!! TRYING TO USE WriteLUTPixelArray() ON BITMAP WITH DEPTH < 8\n"));
1425 return 0;
1426 }
1427
1428 /* Curently only one format is supported */
1429 if (CTABFMT_XRGB8 != ctabformat) {
1430 D(bug("!!! WriteLUTPixelArray() CALLED WITH UNSUPPORTED CTAB FORMAT %d\n"
1431 , ctabformat));
1432 return 0;
1433 }
1434 col.alpha = 0;
1435
1436 /* Convert the coltab into native pixels */
1437 for (i = 0; i < 256; i ++) {
1438 register ULONG rgb = ((ULONG *)ctable)[i];
1439 col.red = (HIDDT_ColComp)((rgb & 0x00FF0000) >> 8);
1440 col.green = (HIDDT_ColComp)(rgb & 0x0000FF00);
1441 col.blue = (HIDDT_ColComp)((rgb & 0x000000FF) << 8);
1442
1443 pixtab[i] = HIDD_BM_MapColor(HIDD_BM_OBJ(rp->BitMap), &col);
1444 }
1445
1446 buf = (UBYTE *)srcrect;
1447
1448 buf += CHUNKY8_COORD_TO_BYTEIDX(srcx, srcy, srcmod);
1449
1450 pixwritten = write_pixels_8(rp
1451 , buf
1452 , srcmod
1453 , destx, desty
1454 , destx + sizex - 1, desty + sizey - 1
1455 , &pixlut
1456 , GfxBase
1457 );
1458
1459
1460 /* Now blit the colors onto the screen */
1461
1462 return pixwritten;
1463 }
1464
1465
1466 LONG driver_WritePixelArray(APTR src, UWORD srcx, UWORD srcy
1467 , UWORD srcmod, struct RastPort *rp, UWORD destx, UWORD desty
1468 , UWORD width, UWORD height, UBYTE srcformat, struct GfxBase *GfxBase)
1469 {
1470
1471 OOP_Object *pf = 0;
1472 HIDDT_StdPixFmt srcfmt_hidd = 0, morphfmt_hidd = 0;
1473 ULONG start_offset;
1474 IPTR bppix;
1475
1476 LONG pixwritten = 0;
1477
1478 struct wpa_render_data wpard;
1479 struct Rectangle rr;
1480
1481 if (RECTFMT_GREY8 == srcformat)
1482 {
1483 static ULONG greytab[256];
1484
1485 /* Ignore possible race conditions during
1486 initialization. Have no bad effect. Just
1487 double initializations. */
1488
1489 /* FIXME/KILLME: evil static array which goes into BSS section
1490 which x86 native AROS regards as evil! */
1491
1492 if (greytab[255] == 0)
1493 {
1494 WORD i;
1495
1496 for(i = 0; i < 256; i++)
1497 {
1498 greytab[i] = i * 0x010101;
1499 }
1500 }
1501
1502 return driver_WriteLUTPixelArray(src, srcx, srcy, srcmod,
1503 rp, greytab, destx, desty,
1504 width, height, CTABFMT_XRGB8,
1505 GfxBase);
1506 }
1507
1508 /* This is cybergraphx. We only work wih HIDD bitmaps */
1509 if (!IS_HIDD_BM(rp->BitMap))
1510 {
1511 D(bug("!!!!! Trying to use CGFX call on non-hidd bitmap in WritePixelArray() !!!\n"));
1512 return 0;
1513 }
1514
1515 if (!OBTAIN_DRIVERDATA(rp, GfxBase))
1516 return 0;
1517
1518 if (RECTFMT_LUT8 == srcformat)
1519 {
1520
1521 HIDDT_PixelLUT pixlut = { 256, HIDD_BM_PIXTAB(rp->BitMap) };
1522 UBYTE * array = (UBYTE *)src;
1523
1524 if (rp->BitMap->Flags & BMF_SPECIALFMT)
1525 {
1526 RELEASE_DRIVERDATA(rp, GfxBase);
1527 D(bug("!!! No CLUT in driver_WritePixelArray\n"));
1528 return 0;
1529 }
1530
1531 array += CHUNKY8_COORD_TO_BYTEIDX(srcx, srcy, srcmod);
1532
1533 pixwritten = write_pixels_8(rp
1534 , array, srcmod
1535 , destx, desty
1536 , destx + width - 1, desty + height - 1
1537 , &pixlut
1538 , GfxBase);
1539
1540 RELEASE_DRIVERDATA(rp, GfxBase);
1541
1542 return pixwritten;
1543 }
1544
1545 switch (srcformat)
1546 {
1547 case RECTFMT_RGB15 : srcfmt_hidd = vHidd_StdPixFmt_RGB15 ; break;
1548 case RECTFMT_BGR15 : srcfmt_hidd = vHidd_StdPixFmt_BGR15 ; break;
1549 case RECTFMT_RGB15PC: srcfmt_hidd = vHidd_StdPixFmt_RGB15_LE; break;
1550 case RECTFMT_BGR15PC: srcfmt_hidd = vHidd_StdPixFmt_BGR15_LE; break;
1551 case RECTFMT_RGB16 : srcfmt_hidd = vHidd_StdPixFmt_RGB16 ; break;
1552 case RECTFMT_BGR16 : srcfmt_hidd = vHidd_StdPixFmt_BGR16 ; break;
1553 case RECTFMT_RGB16PC: srcfmt_hidd = vHidd_StdPixFmt_RGB16_LE; break;
1554 case RECTFMT_BGR16PC: srcfmt_hidd = vHidd_StdPixFmt_BGR16_LE; break;
1555 case RECTFMT_RGB24 : srcfmt_hidd = vHidd_StdPixFmt_RGB24 ; break;
1556 case RECTFMT_BGR24 : srcfmt_hidd = vHidd_StdPixFmt_BGR24 ; break;
1557 case RECTFMT_ARGB32 : srcfmt_hidd = vHidd_StdPixFmt_ARGB32 ; morphfmt_hidd = vHidd_StdPixFmt_0RGB32; break;
1558 case RECTFMT_BGRA32 : srcfmt_hidd = vHidd_StdPixFmt_BGRA32 ; morphfmt_hidd = vHidd_StdPixFmt_BGR032; break;
1559 case RECTFMT_RGBA32 : srcfmt_hidd = vHidd_StdPixFmt_RGBA32 ; morphfmt_hidd = vHidd_StdPixFmt_RGB032; break;
1560 case RECTFMT_ABGR32 : srcfmt_hidd = vHidd_StdPixFmt_ABGR32 ; morphfmt_hidd = vHidd_StdPixFmt_0BGR32; break;
1561 case RECTFMT_RAW : srcfmt_hidd = vHidd_StdPixFmt_Native; break;
1562 }
1563
1564 /* Compute the start of the array */
1565
1566 #warning Get rid of the below code ?
1567 /* This can be done by passing the srcx and srcy parameters on to
1568 the HIDD bitmap and let it take care of it itself.
1569 This means that HIDD_BM_PutImage() gets a lot of parameters,
1570 which may not be necessary in real life.
1571
1572 Compromise: convert from *CyberGfx* pixfmt to bppix using a table lookup.
1573 This is faster
1574 */
1575 if ((srcfmt_hidd == vHidd_StdPixFmt_Native) || (morphfmt_hidd != 0))
1576 {
1577 OOP_GetAttr(HIDD_BM_OBJ(rp->BitMap), aHidd_BitMap_PixFmt, (IPTR *)&pf);
1578 }
1579
1580 if (srcfmt_hidd != vHidd_StdPixFmt_Native)
1581 {
1582 /* RECTFMT_ARGB32 on vHidd_StdPixFmt_0RGB32 bitmap ==> use vHidd_StdPixFmt_0RGB32 */
1583 /* RECTFMT_BGRA32 on vHidd_StdPixFmt_BGR032 bitmap ==> use vHidd_StdPixFmt_BGR032 */
1584 /* RECTFMT_RGBA32 on vHidd_StdPixFmt_RGB032 bitmap ==> use vHidd_StdPixFmt_RGB032 */
1585 /* RECTFMT_ABGR32 on vHidd_StdPixFmt_0BGR32 bitmap ==> use vHidd_StdPixFmt_0BGR32 */
1586
1587 if (morphfmt_hidd != 0)
1588 {
1589 IPTR stdpf;
1590
1591 OOP_GetAttr(pf, aHidd_PixFmt_StdPixFmt, (IPTR *)&stdpf);
1592 if (stdpf == morphfmt_hidd) srcfmt_hidd = morphfmt_hidd;
1593 }
1594
1595 pf = HIDD_Gfx_GetPixFmt(SDD(GfxBase)->gfxhidd, srcfmt_hidd);
1596 }
1597
1598 OOP_GetAttr(pf, aHidd_PixFmt_BytesPerPixel, &bppix);
1599
1600 start_offset = ((ULONG)srcy) * srcmod + srcx * bppix;
1601
1602 wpard.array = ((UBYTE *)src) + start_offset;
1603 wpard.pixfmt = srcfmt_hidd;
1604 wpard.modulo = srcmod;
1605 wpard.bppix = bppix;
1606
1607 rr.MinX = destx;
1608 rr.MinY = desty;
1609 rr.MaxX = destx + width - 1;
1610 rr.MaxY = desty + height - 1;
1611
1612 pixwritten = do_render_func(rp, NULL, &rr, wpa_render, &wpard, FALSE, GfxBase);
1613
1614 RELEASE_DRIVERDATA(rp, GfxBase);
1615
1616 return pixwritten;
1617 }
1618
1619 LONG driver_WritePixelArrayAlpha(APTR src, UWORD srcx, UWORD srcy
1620 , UWORD srcmod, struct RastPort *rp, UWORD destx, UWORD desty
1621 , UWORD width, UWORD height, ULONG globalalpha, struct GfxBase *GfxBase)
1622 {
1623 ULONG start_offset;
1624 LONG pixwritten = 0;
1625 struct wpaa_render_data wpaard;
1626 struct Rectangle rr;
1627
1628 /* This is cybergraphx. We only work wih HIDD bitmaps */
1629 if (!IS_HIDD_BM(rp->BitMap))
1630 {
1631 D(bug("!!!!! Trying to use CGFX call on non-hidd bitmap in WritePixelArrayAlpha() !!!\n"));
1632 return 0;
1633 }
1634
1635 if (!OBTAIN_DRIVERDATA(rp, GfxBase))
1636 return 0;
1637
1638 /* Compute the start of the array */
1639
1640 start_offset = ((ULONG)srcy) * srcmod + srcx * 4;
1641
1642 wpaard.array = ((UBYTE *)src) + start_offset;
1643 wpaard.modulo = srcmod;
1644
1645 rr.MinX = destx;
1646 rr.MinY = desty;
1647 rr.MaxX = destx + width - 1;
1648 rr.MaxY = desty + height - 1;
1649
1650 pixwritten = do_render_func(rp, NULL, &rr, wpaa_render, &wpaard, FALSE, GfxBase);
1651
1652 RELEASE_DRIVERDATA(rp, GfxBase);
1653
1654 return pixwritten;
1655 }
1656
1657 LONG driver_ReadPixelArray(APTR dst, UWORD destx, UWORD desty
1658 , UWORD dstmod, struct RastPort *rp, UWORD srcx, UWORD srcy
1659 , UWORD width, UWORD height, UBYTE dstformat, struct GfxBase *GfxBase)
1660 {
1661
1662 OOP_Object *pf = 0;
1663 HIDDT_StdPixFmt dstfmt_hidd = 0, morphfmt_hidd = 0;
1664
1665 ULONG start_offset;
1666 IPTR bppix;
1667
1668 LONG pixread = 0;
1669 IPTR old_drmd;
1670 OOP_Object *gc;
1671
1672 struct Rectangle rr;
1673 struct rpa_render_data rpard;
1674
1675 struct TagItem gc_tags[] =
1676 {
1677 { aHidd_GC_DrawMode , vHidd_GC_DrawMode_Copy},
1678 { TAG_DONE }
1679 };
1680
1681 /* This is cybergraphx. We only work wih HIDD bitmaps */
1682 if (!IS_HIDD_BM(rp->BitMap))
1683 {
1684 D(bug("!!!!! Trying to use CGFX call on non-hidd bitmap in ReadPixelArray() !!!\n"));
1685 return 0;
1686 }
1687
1688 if (!OBTAIN_DRIVERDATA(rp, GfxBase))
1689 return 0;
1690
1691 gc = GetDriverData(rp)->dd_GC;
1692
1693 /* Preserve old drawmode */
1694 OOP_GetAttr(gc, aHidd_GC_DrawMode, &old_drmd);
1695 OOP_SetAttrs(gc, gc_tags);
1696
1697
1698 switch (dstformat)
1699 {
1700 case RECTFMT_RGB15 : dstfmt_hidd = vHidd_StdPixFmt_RGB15 ; break;
1701 case RECTFMT_BGR15 : dstfmt_hidd = vHidd_StdPixFmt_BGR15 ; break;
1702 case RECTFMT_RGB15PC: dstfmt_hidd = vHidd_StdPixFmt_RGB15_LE; break;
1703 case RECTFMT_BGR15PC: dstfmt_hidd = vHidd_StdPixFmt_BGR15_LE; break;
1704 case RECTFMT_RGB16 : dstfmt_hidd = vHidd_StdPixFmt_RGB16 ; break;
1705 case RECTFMT_BGR16 : dstfmt_hidd = vHidd_StdPixFmt_BGR16 ; break;
1706 case RECTFMT_RGB16PC: dstfmt_hidd = vHidd_StdPixFmt_RGB16_LE; break;
1707 case RECTFMT_BGR16PC: dstfmt_hidd = vHidd_StdPixFmt_BGR16_LE; break;
1708 case RECTFMT_RGB24 : dstfmt_hidd = vHidd_StdPixFmt_RGB24 ; break;
1709 case RECTFMT_BGR24 : dstfmt_hidd = vHidd_StdPixFmt_BGR24 ; break;
1710 case RECTFMT_ARGB32 : dstfmt_hidd = vHidd_StdPixFmt_ARGB32 ; morphfmt_hidd = vHidd_StdPixFmt_0RGB32; break;
1711 case RECTFMT_BGRA32 : dstfmt_hidd = vHidd_StdPixFmt_BGRA32 ; morphfmt_hidd = vHidd_StdPixFmt_BGR032; break;
1712 case RECTFMT_RGBA32 : dstfmt_hidd = vHidd_StdPixFmt_RGBA32 ; morphfmt_hidd = vHidd_StdPixFmt_RGB032; break;
1713 case RECTFMT_ABGR32 : dstfmt_hidd = vHidd_StdPixFmt_ABGR32 ; morphfmt_hidd = vHidd_StdPixFmt_0BGR32; break;
1714 case RECTFMT_RAW : dstfmt_hidd = vHidd_StdPixFmt_Native; break;
1715 }
1716
1717 #warning Get rid of the below code ?
1718 /* This can be done by passing the srcx and srcy parameters on to
1719 the HIDD bitmap and let it take care of it itself.
1720 This means that HIDD_BM_PutImage() gets a lot of parameters,
1721 which may not be necessary in real life.
1722
1723 Compromise: convert from *CyberGfx* pixfmt to bppix using a table lookup.
1724 This is faster
1725 */
1726 if ((dstfmt_hidd == vHidd_StdPixFmt_Native) || (morphfmt_hidd != 0))
1727 {
1728 OOP_GetAttr(HIDD_BM_OBJ(rp->BitMap), aHidd_BitMap_PixFmt, (IPTR *)&pf);
1729 }
1730
1731 if (dstfmt_hidd != vHidd_StdPixFmt_Native)
1732 {
1733 /* RECTFMT_ARGB32 on vHidd_StdPixFmt_0RGB32 bitmap ==> use vHidd_StdPixFmt_0RGB32 */
1734 /* RECTFMT_BGRA32 on vHidd_StdPixFmt_BGR032 bitmap ==> use vHidd_StdPixFmt_BGR032 */
1735 /* RECTFMT_RGBA32 on vHidd_StdPixFmt_RGB032 bitmap ==> use vHidd_StdPixFmt_RGB032 */
1736 /* RECTFMT_ABGR32 on vHidd_StdPixFmt_0BGR32 bitmap ==> use vHidd_StdPixFmt_0BGR32 */
1737
1738 if (morphfmt_hidd != 0)
1739 {
1740 IPTR stdpf;
1741
1742 OOP_GetAttr(pf, aHidd_PixFmt_StdPixFmt, (IPTR *)&stdpf);
1743 if (stdpf == morphfmt_hidd) dstfmt_hidd = morphfmt_hidd;
1744 }
1745
1746 pf = HIDD_Gfx_GetPixFmt(SDD(GfxBase)->gfxhidd, dstfmt_hidd);
1747 }
1748
1749 OOP_GetAttr(pf, aHidd_PixFmt_BytesPerPixel, &bppix);
1750
1751 start_offset = ((ULONG)desty) * dstmod + destx * bppix;
1752
1753 rpard.array = ((UBYTE *)dst) + start_offset;
1754 rpard.pixfmt = dstfmt_hidd;
1755 rpard.modulo = dstmod;
1756 rpard.bppix = bppix;
1757
1758 rr.MinX = srcx;
1759 rr.MinY = srcy;
1760 rr.MaxX = srcx + width - 1;
1761 rr.MaxY = srcy + height - 1;
1762
1763 pixread = do_render_func(rp, NULL, &rr, rpa_render, &rpard, FALSE, GfxBase);
1764
1765 /* restore old gc values */
1766 gc_tags[0].ti_Data = (IPTR)old_drmd;
1767 OOP_SetAttrs(gc, gc_tags);
1768
1769 RELEASE_DRIVERDATA(rp, GfxBase);
1770
1771 return pixread;
1772 }
1773
1774 LONG driver_InvertPixelArray(struct RastPort *rp
1775 , UWORD destx, UWORD desty, UWORD width, UWORD height
1776 , struct GfxBase *GfxBase)
1777 {
1778
1779 /* This is cybergraphx. We only work wih HIDD bitmaps */
1780 if (!IS_HIDD_BM(rp->BitMap))
1781 {
1782 D(bug("!!!!! Trying to use CGFX call on non-hidd bitmap InvertPixelArray() !!!\n"));
1783 return 0;
1784 }
1785
1786 return (LONG)fillrect_pendrmd(rp
1787 , destx, desty
1788 , destx + width - 1
1789 , desty + height - 1
1790 , 0 /* Source pen does not matter */
1791 , vHidd_GC_DrawMode_Invert
1792 , GfxBase);
1793 }
1794
1795 LONG driver_FillPixelArray(struct RastPort *rp
1796 , UWORD destx, UWORD desty, UWORD width, UWORD height
1797 , ULONG pixel, struct GfxBase *GfxBase)
1798 {
1799 HIDDT_Color col;
1800 HIDDT_Pixel pix;
1801
1802 /* HIDDT_ColComp are 16 Bit */
1803 col.alpha = (HIDDT_ColComp)((pixel >> 16) & 0x0000FF00);
1804 col.red = (HIDDT_ColComp)((pixel >> 8) & 0x0000FF00);
1805 col.green = (HIDDT_ColComp)(pixel & 0x0000FF00);
1806 col.blue = (HIDDT_ColComp)((pixel << 8) & 0x0000FF00);
1807
1808 pix = HIDD_BM_MapColor(HIDD_BM_OBJ(rp->BitMap), &col);
1809
1810 return (LONG)fillrect_pendrmd(rp
1811 , destx, desty
1812 , destx + width - 1
1813 , desty + height - 1
1814 , pix
1815 , vHidd_GC_DrawMode_Copy
1816 , GfxBase
1817 );
1818 }
1819
1820 ULONG driver_MovePixelArray(UWORD srcx, UWORD srcy, struct RastPort *rp
1821 , UWORD destx, UWORD desty, UWORD width, UWORD height
1822 , struct GfxBase *GfxBase)
1823 {
1824 ClipBlit(rp
1825 , srcx, srcy
1826 , rp
1827 , destx, desty
1828 , width, height
1829 , 0x00C0 /* Copy */
1830 );
1831 return width * height;
1832 }
1833
1834
1835
1836 LONG driver_WriteRGBPixel(struct RastPort *rp, UWORD x, UWORD y
1837 , ULONG pixel, struct GfxBase *GfxBase)
1838 {
1839
1840 struct rgbpix_render_data prd;
1841 HIDDT_Color col;
1842 LONG retval;
1843
1844 /* This is cybergraphx. We only work wih HIDD bitmaps */
1845 if (!IS_HIDD_BM(rp->BitMap))
1846 {
1847 D(bug("!!!!! Trying to use CGFX call on non-hidd bitmap in WriteRGBPixel() !!!\n"));
1848 return 0;
1849 }
1850
1851 if (!OBTAIN_DRIVERDATA(rp, GfxBase)) return -1;
1852
1853 /* HIDDT_ColComp are 16 Bit */
1854
1855 col.alpha = (HIDDT_ColComp)((pixel >> 16) & 0x0000FF00);
1856 col.red = (HIDDT_ColComp)((pixel >> 8) & 0x0000FF00);
1857 col.green = (HIDDT_ColComp)(pixel & 0x0000FF00);
1858 col.blue = (HIDDT_ColComp)((pixel << 8) & 0x0000FF00);
1859
1860 prd.pixel = HIDD_BM_MapColor(HIDD_BM_OBJ(rp->BitMap), &col);
1861
1862 retval = do_pixel_func(rp, x, y, rgbpix_write, &prd, GfxBase);
1863
1864 RELEASE_DRIVERDATA(rp, GfxBase);
1865
1866 return retval;
1867
1868 }
1869
1870
1871 ULONG driver_ReadRGBPixel(struct RastPort *rp, UWORD x, UWORD y
1872 , struct GfxBase *GfxBase)
1873 {
1874 struct rgbpix_render_data prd;
1875
1876 /* Get the HIDD pixel val */
1877 HIDDT_Color col;
1878 HIDDT_Pixel pix;
1879 LONG ret;
1880
1881 /* This is cybergraphx. We only work wih HIDD bitmaps */
1882 if (!IS_HIDD_BM(rp->BitMap))
1883 {
1884 D(bug("!!!!! Trying to use CGFX call on non-hidd bitmap in ReadRGBPixel()!!!\n"));
1885 return (ULONG)-1;
1886 }
1887
1888 if (!OBTAIN_DRIVERDATA(rp, GfxBase)) return (ULONG)-1;
1889
1890 ret = do_pixel_func(rp, x, y, pix_read, &prd, GfxBase);
1891
1892 RELEASE_DRIVERDATA(rp, GfxBase);
1893
1894 if (-1 == ret)
1895 return (ULONG)-1;
1896
1897 HIDD_BM_UnmapPixel(HIDD_BM_OBJ(rp->BitMap), prd.pixel, &col);
1898
1899 /* HIDDT_ColComp are 16 Bit */
1900
1901 pix = ((col.alpha & 0xFF00) << 16)
1902 | ((col.red & 0xFF00) << 8)
1903 | (col.green & 0xFF00)
1904 | ((col.blue & 0xFF00) >> 8);
1905
1906 return pix;
1907 }
1908
1909
1910
1911 ULONG driver_GetCyberMapAttr(struct BitMap *bitMap, ULONG attribute, struct GfxBase *GfxBase)
1912 {
1913 OOP_Object *bm_obj;
1914 OOP_Object *pf;
1915
1916 IPTR retval;
1917
1918 /* This is cybergraphx. We only work wih HIDD bitmaps */
1919 if (!IS_HIDD_BM(bitMap)) {
1920 D(bug("!!!!! Trying to use CGFX call on non-hidd bitmap in GetCyberMapAttr() !!!\n"));
1921 return 0;
1922 }
1923
1924 bm_obj = HIDD_BM_OBJ(bitMap);
1925
1926 OOP_GetAttr(bm_obj, aHidd_BitMap_PixFmt, (IPTR *)&pf);
1927
1928 switch (attribute) {
1929 case CYBRMATTR_XMOD:
1930 OOP_GetAttr(bm_obj, aHidd_BitMap_BytesPerRow, &retval);
1931 break;
1932
1933 case CYBRMATTR_BPPIX:
1934 OOP_GetAttr(pf, aHidd_PixFmt_BytesPerPixel, &retval);
1935 break;
1936
1937 case CYBRMATTR_PIXFMT: {
1938 IPTR stdpf;
1939 UWORD cpf;
1940 OOP_GetAttr(pf, aHidd_PixFmt_StdPixFmt, (IPTR *)&stdpf);
1941
1942 /* Convert to cybergfx */
1943 cpf = hidd2cyber_pixfmt(stdpf, GfxBase);
1944
1945 if (cpf == (UWORD)-1) {
1946 D(bug("!!! UNKNOWN PIXEL FORMAT IN GetCyberMapAttr()\n"));
1947 }
1948
1949 retval = (IPTR)cpf;
1950 break;
1951
1952 }
1953
1954 case CYBRMATTR_WIDTH:
1955 #if 0 /* stegerg: doesn't really work, because of framebuffer bitmap object stuff */
1956 OOP_GetAttr(bm_obj, aHidd_BitMap_Width, &retval);
1957 #else
1958 retval = GetBitMapAttr(bitMap, BMA_WIDTH);
1959 #endif
1960 break;
1961
1962 case CYBRMATTR_HEIGHT:
1963 #if 0 /* stegerg: doesn't really work, because of framebuffer bitmap object stuff */
1964 OOP_GetAttr(bm_obj, aHidd_BitMap_Height, &retval);
1965 #else
1966 retval = GetBitMapAttr(bitMap, BMA_HEIGHT);
1967 #endif
1968 break;
1969
1970 case CYBRMATTR_DEPTH:
1971 #if 0 /* stegerg: might not really work, because of framebuffer bitmap object stuff */
1972 OOP_GetAttr(pf, aHidd_PixFmt_Depth, &retval);
1973 #else
1974 retval = GetBitMapAttr(bitMap, BMA_DEPTH);
1975 #endif
1976 break;
1977
1978 case CYBRMATTR_ISCYBERGFX: {
1979 IPTR depth;
1980
1981 OOP_GetAttr(pf, aHidd_PixFmt_Depth, &depth);
1982
1983 if (depth < 8) {
1984 retval = 0;
1985 } else {
1986 /* We allways have a HIDD bitmap */
1987 retval = 0xFFFFFFFF; /* Some apps seem to rely on this retval */
1988 }
1989 break; }
1990
1991 case CYBRMATTR_ISLINEARMEM:
1992 OOP_GetAttr(bm_obj, aHidd_BitMap_IsLinearMem, &retval);
1993 break;
1994
1995 default:
1996 D(bug("!!! UNKNOWN ATTRIBUTE PASSED TO GetCyberMapAttr()\n"));
1997 break;
1998
1999
2000 } /* switch (attribute) */
2001
2002 return retval;
2003 }
2004
2005
2006 VOID driver_CVideoCtrlTagList(struct ViewPort *vp, struct TagItem *tags, struct GfxBase *GfxBase)
2007 {
2008 struct TagItem *tag, *tstate;
2009 ULONG dpmslevel = 0;
2010
2011 struct TagItem htags[] =
2012 {
2013 { aHidd_Gfx_DPMSLevel, 0UL },
2014 { TAG_DONE, 0UL }
2015 };
2016
2017 BOOL dpms_found = FALSE;
2018
2019 HIDDT_DPMSLevel hdpms = 0;
2020
2021 for (tstate = tags; (tag = NextTagItem((const struct TagItem **)&tstate)); )
2022 {
2023 switch (tag->ti_Tag)
2024 {
2025 case SETVC_DPMSLevel:
2026 dpmslevel = tag->ti_Data;
2027 dpms_found = TRUE;
2028 break;
2029
2030 default:
2031 D(bug("!!! UNKNOWN TAG IN CVideoCtrlTagList(): %x !!!\n"
2032 , tag->ti_Tag));
2033 break;
2034
2035 } /* switch() */
2036
2037 } /* for (each tagitem) */
2038
2039
2040 if (dpms_found)
2041 {
2042
2043 /* Convert to hidd dpms level */
2044 switch (dpmslevel)
2045 {
2046 case DPMS_ON:
2047 hdpms = vHidd_Gfx_DPMSLevel_On;
2048 break;
2049
2050 case DPMS_STANDBY:
2051 hdpms = vHidd_Gfx_DPMSLevel_Standby;
2052 break;
2053
2054 case DPMS_SUSPEND:
2055 hdpms = vHidd_Gfx_DPMSLevel_Suspend;
2056 break;
2057
2058 case DPMS_OFF:
2059 hdpms = vHidd_Gfx_DPMSLevel_Off;
2060 break;
2061
2062 default:
2063 D(bug("!!! UNKNOWN DPMS LEVEL IN CVideoCtrlTagList(): %x !!!\n"
2064 , dpmslevel));
2065
2066 dpms_found = FALSE;
2067 break;
2068
2069 }
2070 }
2071
2072 if (dpms_found)
2073 {
2074 htags[0].ti_Data = hdpms;
2075 }
2076 else
2077 {
2078 htags[0].ti_Tag = TAG_IGNORE;
2079 }
2080
2081 OOP_SetAttrs(SDD(GfxBase)->gfxhidd, htags);
2082
2083 return;
2084 }
2085
2086
2087 ULONG driver_ExtractColor(struct RastPort *rp, struct BitMap *bm
2088 , ULONG color, ULONG srcx, ULONG srcy, ULONG width, ULONG height
2089 , struct GfxBase *GfxBase)
2090 {
2091 struct Rectangle rr;
2092 LONG pixread = 0;
2093 struct extcol_render_data ecrd;
2094 OOP_Object *pf;
2095 IPTR colmod;
2096
2097 if (!IS_HIDD_BM(rp->BitMap))
2098 {
2099 D(bug("!!! CALLING ExtractColor() ON NO-HIDD BITMAP !!!\n"));
2100 return FALSE;
2101 }
2102
2103 if (!OBTAIN_DRIVERDATA(rp, GfxBase))
2104 return FALSE;
2105
2106 rr.MinX = srcx;
2107 rr.MinY = srcy;
2108 rr.MaxX = srcx + width - 1;
2109 rr.MaxY = srcy + height - 1;
2110
2111 OOP_GetAttr(HIDD_BM_OBJ(rp->BitMap), aHidd_BitMap_PixFmt, (IPTR *)&pf);
2112
2113 OOP_GetAttr(pf, aHidd_PixFmt_ColorModel, (IPTR *)&colmod);
2114
2115 if (vHidd_ColorModel_Palette == colmod)
2116 {
2117 ecrd.pixel = color;
2118 }
2119 else
2120 {
2121 HIDDT_Color col;
2122
2123 col.alpha = (color >> 16) & 0x0000FF00;
2124 col.red = (color >> 8 ) & 0x0000FF00;
2125 col.green = color & 0x0000FF00;
2126 col.blue = (color << 8) & 0x0000FF00;
2127
2128 ecrd.pixel = HIDD_BM_MapColor(HIDD_BM_OBJ(rp->BitMap), &col);
2129
2130 }
2131
2132 ecrd.destbm = bm;
2133
2134 pixread = do_render_func(rp, NULL, &rr, extcol_render, NULL, TRUE, GfxBase);
2135
2136 RELEASE_DRIVERDATA(rp, GfxBase);
2137
2138 if (pixread != (width * height))
2139 return FALSE;
2140
2141 return TRUE;
2142 }
2143
2144
2145 VOID driver_DoCDrawMethodTagList(struct Hook *hook, struct RastPort *rp, struct TagItem *tags, struct GfxBase *GfxBase)
2146 {
2147
2148 struct dm_render_data dmrd;
2149 struct Rectangle rr;
2150 struct Layer *L;
2151
2152 if (!IS_HIDD_BM(rp->BitMap))
2153 {
2154 D(bug("!!! NO HIDD BITMAP IN CALL TO DoCDrawMethodTagList() !!!\n"));
2155 return;
2156 }
2157
2158 if (!OBTAIN_DRIVERDATA(rp, GfxBase))
2159 return;
2160
2161 /* Get the bitmap std pixfmt */
2162 OOP_GetAttr(HIDD_BM_OBJ(rp->BitMap), aHidd_BitMap_PixFmt, (IPTR *)&dmrd.pf);
2163 OOP_GetAttr(dmrd.pf, aHidd_PixFmt_StdPixFmt, &dmrd.stdpf);
2164 dmrd.msg.colormodel = hidd2cyber_pixfmt(dmrd.stdpf, GfxBase);
2165 dmrd.hook = hook;
2166 dmrd.rp = rp;
2167
2168 if (((UWORD)-1) == dmrd.msg.colormodel)
2169 {
2170 RELEASE_DRIVERDATA(rp, GfxBase);
2171 D(bug("!!! UNKNOWN HIDD PIXFMT IN DoCDrawMethodTagList() !!!\n"));
2172 return;
2173 }
2174
2175
2176 L = rp->Layer;
2177
2178 rr.MinX = 0;
2179 rr.MinY = 0;
2180
2181 if (NULL == L)
2182 {
2183 rr.MaxX = GetBitMapAttr(rp->BitMap, BMA_WIDTH) - 1;
2184 rr.MaxY = GetBitMapAttr(rp->BitMap, BMA_HEIGHT) - 1;
2185 }
2186 else
2187 {
2188 /* Lock the layer */
2189 LockLayerRom(L);
2190
2191 rr.MaxX = rr.MinX + (L->bounds.MaxX - L->bounds.MinX) - 1;
2192 rr.MaxY = rr.MinY + (L->bounds.MaxY - L->bounds.MinY) - 1;
2193 }
2194
2195 dmrd.gc = GetDriverData(rp)->dd_GC;
2196 do_render_func(rp, NULL, &rr, dm_render, &dmrd, FALSE, GfxBase);
2197
2198 RELEASE_DRIVERDATA(rp, GfxBase);
2199
2200 if (NULL != L)
2201 {
2202 UnlockLayerRom(L);
2203 }
2204
2205 return;
2206 }
2207
2208 APTR driver_LockBitMapTagList(struct BitMap *bm, struct TagItem *tags, struct GfxBase *GfxBase)
2209 {
2210 struct TagItem *tag;
2211 UBYTE *baseaddress;
2212 ULONG width, height, banksize, memsize;
2213 OOP_Object *pf;
2214 IPTR stdpf;
2215 UWORD cpf;
2216
2217 if (!IS_HIDD_BM(bm))
2218 {
2219 D(bug("!!! TRYING TO CALL LockBitMapTagList() ON NON-HIDD BM !!!\n"));
2220 return NULL;
2221 }
2222
2223 OOP_GetAttr(HIDD_BM_OBJ(bm), aHidd_BitMap_PixFmt, (IPTR *)&pf);
2224
2225 OOP_GetAttr(pf, aHidd_PixFmt_StdPixFmt, &stdpf);
2226 cpf = hidd2cyber_pixfmt(stdpf, GfxBase);
2227 if (((UWORD)-1) == cpf)
2228 {
2229 D(bug("!!! TRYING TO CALL LockBitMapTagList() ON NON-CYBER PIXFMT BITMAP !!!\n"));
2230 return NULL;
2231 }
2232
2233 /* Get some info from the bitmap object */
2234 if (!HIDD_BM_ObtainDirectAccess(HIDD_BM_OBJ(bm), &baseaddress, &width, &height, &banksize, &memsize))
2235 return NULL;
2236
2237
2238 while ((tag = NextTagItem((const struct TagItem **)&tags)))
2239 {
2240 switch (tag->ti_Tag)
2241 {
2242 case LBMI_BASEADDRESS:
2243 *((IPTR **)tag->ti_Data) = (IPTR *)baseaddress;
2244 break;
2245
2246 case LBMI_BYTESPERROW:
2247 *((IPTR *)tag->ti_Data) =
2248 (ULONG)HIDD_BM_BytesPerLine(HIDD_BM_OBJ(bm), stdpf, width);
2249 break;
2250
2251 case LBMI_BYTESPERPIX:
2252 OOP_GetAttr(pf, aHidd_PixFmt_BytesPerPixel, (IPTR *)tag->ti_Data);
2253 break;
2254
2255 case LBMI_PIXFMT:
2256 *((IPTR *)tag->ti_Data) = (IPTR)cpf;
2257 break;
2258
2259 case LBMI_DEPTH:
2260 OOP_GetAttr(pf, aHidd_PixFmt_Depth, (IPTR *)tag->ti_Data);
2261 break;
2262
2263 case LBMI_WIDTH:
2264 OOP_GetAttr(HIDD_BM_OBJ(bm), aHidd_BitMap_Width, (IPTR *)tag->ti_Data);
2265 break;
2266
2267 case LBMI_HEIGHT:
2268 OOP_GetAttr(HIDD_BM_OBJ(bm), aHidd_BitMap_Height, (IPTR *)tag->ti_Data);
2269 break;
2270
2271 default:
2272 D(bug("!!! UNKNOWN TAG PASSED TO LockBitMapTagList() !!!\n"));
2273 break;
2274 }
2275 }
2276
2277 return HIDD_BM_OBJ(bm);
2278 }
2279
2280 VOID driver_UnLockBitMap(APTR handle, struct GfxBase *GfxBase)
2281 {
2282 if (handle) HIDD_BM_ReleaseDirectAccess((OOP_Object *)handle);
2283 }
2284
2285 VOID driver_UnLockBitMapTagList(APTR handle, struct TagItem *tags, struct GfxBase *GfxBase)
2286 {
2287 struct TagItem *tag;
2288 BOOL reallyunlock = TRUE;
2289
2290 while ((tag = NextTagItem((const struct TagItem **)&tags)))
2291 {
2292 switch (tag->ti_Tag)
2293 {
2294 case UBMI_REALLYUNLOCK:
2295 reallyunlock = (BOOL)tag->ti_Data;
2296 break;
2297
2298 case UBMI_UPDATERECTS:
2299 {
2300 struct RectList *rl;
2301
2302 rl = (struct RectList *)tag->ti_Data;
2303
2304 #warning Dunno what to do with this
2305
2306 break;
2307 }
2308
2309 default:
2310 D(bug("!!! UNKNOWN TAG PASSED TO UnLockBitMapTagList() !!!\n"));
2311 break;
2312 }
2313 }
2314
2315 if (reallyunlock)
2316 {
2317 HIDD_BM_ReleaseDirectAccess((OOP_Object *)handle);
2318 }
2319 }
2320
2321 void driver_BltTemplateAlpha(UBYTE *src, LONG srcx, LONG srcmod
2322 , struct RastPort *rp, LONG destx, LONG desty, LONG width, LONG height
2323 , struct GfxBase *GfxBase)
2324 {
2325 struct bta_render_data btard;
2326 struct Rectangle rr;
2327
2328 /* This is cybergraphx. We only work wih HIDD bitmaps */
2329 if (!IS_HIDD_BM(rp->BitMap)) {
2330 D(bug("!!!!! Trying to use CGFX call on non-hidd bitmap in BltTemplateAlpha() !!!\n"));
2331 return;
2332 }
2333
2334 if (!OBTAIN_DRIVERDATA(rp, GfxBase))
2335 return;
2336
2337 /* Compute the start of the array */
2338
2339 btard.array = src + srcx;
2340 btard.modulo = srcmod;
2341 btard.invertalpha = (rp->DrawMode & INVERSVID) ? TRUE : FALSE;
2342 rr.MinX = destx;
2343 rr.MinY = desty;
2344 rr.MaxX = destx + width - 1;
2345 rr.MaxY = desty + height - 1;
2346
2347 do_render_func(rp, NULL, &rr, bta_render, &btard, FALSE, GfxBase);
2348
2349 RELEASE_DRIVERDATA(rp, GfxBase);
2350 }
2351
2352 /******************************************/
2353 /* Support stuff for cybergfx */
2354 /******************************************/
2355
2356 #undef GfxBase
2357
A totally sweet operating system