?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Fixed warnings and removed comparisons against TRUE.
[tangerine.git] / rom / graphics / graphics_driver.c
blobc392c4178530ca076ecff9389db48d587effa3a8
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 01,03,00,00,00,00,00,00,00,00,00,
527 02,01,03,03,00,00,00,00,00,00,00,
528 00,02,01,01,03,03,00,00,00,00,00,
529 00,02,01,01,01,01,03,03,00,00,00,
530 00,00,02,01,01,01,01,01,03,03,00,
531 00,00,02,01,01,01,01,01,01,01,00,
532 00,00,00,02,01,01,01,03,00,00,00,
533 00,00,00,02,01,01,03,01,03,00,00,
534 00,00,00,00,02,01,00,02,01,03,00,
535 00,00,00,00,02,01,00,00,02,01,03,
536 00,00,00,00,00,00,00,00,00,01,01
537 };
538
539 #define DEF_POINTER_WIDTH 11
540 #define DEF_POINTER_HEIGHT 11
541 #define DEF_POINTER_DEPTH 4
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] = {0};
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 = 0xE0E0;
573 col[1].green = 0x4040;
574 col[1].blue = 0x4040;
575 col[1].alpha = 0x0000;
576 col[2].red = 0x0000;
577 col[2].green = 0x0000;
578 col[2].blue = 0x0000;
579 col[2].alpha = 0x0000;
580 col[3].red = 0xE0E0;
581 col[3].green = 0xE0E0;
582 col[3].blue = 0xC0C0;
583 col[3].alpha = 0x0000;
584
585 HIDD_BM_SetColors(SDD(GfxBase)->pointerbm, col, 0, DEF_POINTER_DEPTH);
586
587 OOP_SetAttrs(gc, gc_tags);
588 #if 0
589 /* PutImageLUT not yet implemented in gfx baseclass */
590 HIDD_BM_PutImageLUT(SDD(GfxBase)->pointerbm, gc
591 , (UBYTE *)def_pointer_shape
592 , DEF_POINTER_WIDTH
593 , 0, 0
594 , DEF_POINTER_WIDTH, DEF_POINTER_HEIGHT
595 , &plut
596 );
597 #else
598 HIDD_BM_PutImage(SDD(GfxBase)->pointerbm, gc
599 , (UBYTE *)def_pointer_shape
600 , DEF_POINTER_WIDTH
601 , 0, 0
602 , DEF_POINTER_WIDTH, DEF_POINTER_HEIGHT
603 , vHidd_StdPixFmt_LUT8
604 );
605
606 #endif
607 release_cache_object(SDD(GfxBase)->gc_cache, gc, GfxBase);
608
609 if (HIDD_Gfx_SetCursorShape(SDD(GfxBase)->gfxhidd, SDD(GfxBase)->pointerbm)) {
610 D(bug("CURSOR SHAPE SET\n"));
611 /* Make it visible */
612 HIDD_Gfx_SetCursorVisible(SDD(GfxBase)->gfxhidd, TRUE);
613
614 return TRUE;
615 }
616 }
617 }
618
619 cleanup_cursor(GfxBase);
620
621 return FALSE;
622 }
623
624 static VOID cleanup_cursor(struct GfxBase *GfxBase)
625 {
626 if (NULL != SDD(GfxBase)->pointerbm) {
627 OOP_DisposeObject(SDD(GfxBase)->pointerbm);
628 SDD(GfxBase)->pointerbm = NULL;
629 }
630 }
631
632 BOOL driver_LateGfxInit (APTR data, struct GfxBase *GfxBase)
633 {
634
635 /* Supplied data is really the librarybase of a HIDD */
636 STRPTR gfxhiddname = (STRPTR)data;
637 struct TagItem tags[] = {
638 { TAG_DONE, 0UL },
639 };
640 EnterFunc(bug("driver_LateGfxInit(gfxhiddname=%s)\n", gfxhiddname));
641
642 /* Create a new GfxHidd object */
643
644 SDD(GfxBase)->gfxhidd = SDD(GfxBase)->gfxhidd_orig = OOP_NewObject(NULL, gfxhiddname, tags);
645 D(bug("driver_LateGfxInit: gfxhidd=%p\n", SDD(GfxBase)->gfxhidd));
646
647 if (NULL != SDD(GfxBase)->gfxhidd) {
648 IPTR hwcursor;
649 BOOL ok = TRUE;
650
651 /* Get method id here, to avoid any possible semaphore involment when calling the method */
652 SDD(GfxBase)->hiddGfxShowImminentReset_MethodID = OOP_GetMethodID(IID_Hidd_Gfx, moHidd_Gfx_ShowImminentReset);
653
654 OOP_GetAttr(SDD(GfxBase)->gfxhidd, aHidd_Gfx_SupportsHWCursor, &hwcursor);
655 SDD(GfxBase)->has_hw_cursor = (BOOL)hwcursor;
656 if (!hwcursor) {
657 OOP_Object *fgh;
658 D(bug("There's no hardware cursor\n"));
659
660 fgh = init_fakegfxhidd(SDD(GfxBase)->gfxhidd
661 , &SDD(GfxBase)->fakegfx_staticdata
662 , GfxBase);
663
664 if (NULL != fgh) {
665 SDD(GfxBase)->gfxhidd = fgh;
666 SDD(GfxBase)->fakegfx_inited = TRUE;
667 } else {
668 ok = FALSE;
669 }
670 }
671
672 if (ok) {
673 struct TagItem gc_create_tags[] = { { TAG_DONE, 0UL } };
674 D(bug("Ok\n"));
675 SDD(GfxBase)->gc_cache = create_object_cache(NULL, IID_Hidd_GC, gc_create_tags, GfxBase);
676 if (NULL != SDD(GfxBase)->gc_cache) {
677
678 struct TagItem bm_create_tags[] = {
679 #warning Maybe make this class private and create the object through the graphicshidd
680 { aHidd_BitMap_GfxHidd, (IPTR)SDD(GfxBase)->gfxhidd_orig },
681 { aHidd_BitMap_Displayable, FALSE },
682 { aHidd_PlanarBM_AllocPlanes, FALSE },
683 { TAG_DONE, 0UL }
684 };
685
686 D(bug("Cache created\n"));
687 SDD(GfxBase)->planarbm_cache = create_object_cache(NULL, CLID_Hidd_PlanarBM, bm_create_tags, GfxBase);
688
689 if (NULL != SDD(GfxBase)->planarbm_cache) {
690
691 /* Move the modes into the displayinfo DB */
692 SDD(GfxBase)->dispinfo_db = build_dispinfo_db(GfxBase);
693 if (NULL != SDD(GfxBase)->dispinfo_db) {
694
695 SDD(GfxBase)->framebuffer = create_framebuffer(GfxBase);
696 if (NULL != SDD(GfxBase)->framebuffer) {
697 D(bug("FRAMEBUFFER OK: %p\n", SDD(GfxBase)->framebuffer));
698 if (init_cursor(GfxBase)) {
699
700 D(bug("MOUSE INITED\n"));
701 ReturnBool("driver_LateGfxInit", TRUE);
702 }
703 OOP_DisposeObject(SDD(GfxBase)->framebuffer);
704 } /* if (framebuffer inited) */
705 destroy_dispinfo_db(SDD(GfxBase)->dispinfo_db, GfxBase);
706 SDD(GfxBase)->dispinfo_db = NULL;
707 } /* if (displayinfo db inited) */
708 delete_object_cache(SDD(GfxBase)->planarbm_cache, GfxBase);
709 SDD(GfxBase)->planarbm_cache = NULL;
710 } /* if (planarbm cache created) */
711 delete_object_cache(SDD(GfxBase)->gc_cache, GfxBase);
712 SDD(GfxBase)->gc_cache = NULL;
713 } /* if (gc object cache ok) */
714
715 } /* if (fake gfx stuff ok) */
716
717 if (SDD(GfxBase)->fakegfx_inited) {
718 cleanup_fakegfxhidd(&SDD(GfxBase)->fakegfx_staticdata, GfxBase);
719 SDD(GfxBase)->fakegfx_inited = FALSE;
720 }
721 OOP_DisposeObject(SDD(GfxBase)->gfxhidd_orig);
722 SDD(GfxBase)->gfxhidd_orig = NULL;
723
724 }
725
726 ReturnBool("driver_LateGfxInit", FALSE);
727
728 }
729
730
731 #if 0 /* Unused? */
732
733 static ULONG getbitmappixel(struct BitMap *bm
734 , LONG x
735 , LONG y
736 , UBYTE depth
737 , UBYTE plane_mask)
738 {
739 UBYTE i;
740 ULONG idx;
741
742 ULONG mask;
743 ULONG pen = 0;
744
745 idx = COORD_TO_BYTEIDX(x, y, bm->BytesPerRow);
746 mask = XCOORD_TO_MASK( x );
747
748 for (i = depth - 1; depth; i -- , depth -- )
749 {
750 pen <<= 1; /* stegerg: moved to here, was inside if!? */
751
752 if ((1L << i) & plane_mask)
753 {
754 UBYTE *plane = bm->Planes[i];
755
756 if (plane == (PLANEPTR)-1)
757 {
758 pen |= 1;
759 }
760 else if (plane != NULL)
761 {
762 if ((plane[idx] & mask) != 0)
763 pen |= 1;
764 }
765 }
766
767 }
768 return pen;
769 }
770
771 #endif
772
773
774 #define dumprect(rect) \
775 kprintf(#rect " : (%d,%d) - (%d,%d)\n",(rect)->MinX,(rect)->MinY,(rect)->MaxX,(rect)->MaxY)
776
777
778 struct bgf_render_data {
779 WORD fbm_xsrc;
780 OOP_Object *fbm;
781 };
782
783 static ULONG bgf_render(APTR bgfr_data
784 , LONG srcx, LONG srcy
785 , OOP_Object *dstbm_obj, OOP_Object *dst_gc
786 , LONG x1, LONG y1, LONG x2, LONG y2
787 , struct GfxBase *GfxBase)
788 {
789 struct bgf_render_data *bgfrd;
790 ULONG width, height;
791
792 width = x2 - x1 + 1;
793 height = y2 - y1 + 1;
794
795 ASSERT(width > 0 && height > 0);
796
797 bgfrd = (struct bgf_render_data *)bgfr_data;
798
799 HIDD_BM_BlitColorExpansion( dstbm_obj
800 , dst_gc
801 , bgfrd->fbm
802 , srcx + bgfrd->fbm_xsrc, srcy /* stegerg: instead of srcy there was a 0 */
803 , x1, y1
804 , width, height
805 );
806
807 return width * height;
808
809 }
810
811 void blit_glyph_fast(struct RastPort *rp, OOP_Object *fontbm, WORD xsrc
812 , WORD destx, WORD desty, UWORD width, UWORD height
813 , struct GfxBase * GfxBase)
814 {
815
816 struct Rectangle rr;
817 struct bgf_render_data bgfrd;
818
819 EnterFunc(bug("blit_glyph_fast(%d, %d, %d, %d, %d)\n"
820 , xsrc, destx, desty, width, height));
821
822
823 ASSERT(width > 0 && height > 0);
824
825 bgfrd.fbm_xsrc = xsrc;
826 bgfrd.fbm = fontbm;
827
828 rr.MinX = destx;
829 rr.MinY = desty;
830 rr.MaxX = destx + width - 1;
831 rr.MaxY = desty + height - 1;
832
833 if (!OBTAIN_DRIVERDATA(rp, GfxBase))
834 ReturnVoid("blit_glyph_fast");
835
836 do_render_func(rp, NULL, &rr, bgf_render, &bgfrd, FALSE, GfxBase);
837
838 RELEASE_DRIVERDATA(rp, GfxBase);
839
840 ReturnVoid("blit_glyph_fast");
841 }
842
843
844
845 #define NUMCHARS(tf) ((tf->tf_HiChar - tf->tf_LoChar) + 2)
846 #define CTF(x) ((struct ColorTextFont *)x)
847
848 void driver_Text (struct RastPort * rp, CONST_STRPTR string, LONG len,
849 struct GfxBase * GfxBase)
850 {
851
852 #warning Does not handle color textfonts
853 WORD render_y;
854 struct TextFont *tf;
855 WORD current_x;
856 OOP_Object *fontbm = NULL;
857
858 if (!OBTAIN_DRIVERDATA(rp, GfxBase))
859 return;
860
861 if ((rp->DrawMode & ~INVERSVID) == JAM2)
862 {
863 struct TextExtent te;
864 ULONG old_drmd = GetDrMd(rp);
865
866 /* This is actually needed, because below only the
867 part of the glyph which contains data is rendered:
868
869 ...1100...
870 ...1100...
871 ...1100...
872 ...1111...
873
874 '.' at left side can be there because of kerning.
875 '.' at the right side can be there because of
876 CharSpace being bigger than glyph bitmap data
877 width.
878 */
879
880 TextExtent(rp, string, len, &te);
881 SetDrMd(rp, old_drmd ^ INVERSVID);
882 RectFill(rp, rp->cp_x + te.te_Extent.MinX,
883 rp->cp_y + te.te_Extent.MinY,
884 rp->cp_x + te.te_Extent.MaxX,
885 rp->cp_y + te.te_Extent.MaxY);
886 SetDrMd(rp, old_drmd);
887 }
888
889 /* does this rastport have a layer. If yes, lock the layer it.*/
890 if (NULL != rp->Layer)
891 LockLayerRom(rp->Layer);
892
893 tf = rp->Font;
894
895 if (ExtendFont(tf, NULL))
896 {
897 fontbm = TFE_INTERN(tf->tf_Extension)->hash->font_bitmap;
898 }
899
900 /* Check if font has character data as a HIDD bitmap */
901
902 if (NULL == fontbm)
903 {
904 D(bug("FONT HAS NO HIDD BITMAP ! Won't render text\n"));
905 RELEASE_DRIVERDATA(rp, GfxBase);
906 return;
907 }
908
909
910 /* Render along font's baseline */
911 render_y = rp->cp_y - tf->tf_Baseline;
912 current_x = rp->cp_x;
913
914 while ( len -- )
915 {
916 ULONG charloc;
917 ULONG idx;
918
919 if (*string < tf->tf_LoChar || *string > tf->tf_HiChar )
920 {
921 /* A character which there is no glyph for. We just
922 draw the last glyph in the font
923 */
924 idx = NUMCHARS(tf) - 1;
925 }
926 else
927 {
928 idx = *string - tf->tf_LoChar;
929 }
930
931 charloc = ((ULONG *)tf->tf_CharLoc)[idx];
932
933 if (tf->tf_CharKern)
934 {
935 current_x += ((WORD *)tf->tf_CharKern)[idx];
936 }
937
938 if ((tf->tf_Style & FSF_COLORFONT) &&
939 !(CTF(tf)->ctf_Flags & CT_ANTIALIAS))
940 {
941 #warning Handle color fonts
942 }
943 else
944 {
945 WORD
946 glyphXOffset = charloc >> 16,
947 glyphWidth = charloc & 0xFFFF;
948
949 ASSERT(tf->tf_YSize > 0);
950
951 /* blit the glypth if it has data in the bitmap */
952 if (glyphWidth > 0)
953 {
954 blit_glyph_fast(rp, fontbm, glyphXOffset, current_x, render_y,
955 glyphWidth, tf->tf_YSize, GfxBase);
956 }
957 }
958
959 if (tf->tf_CharSpace)
960 current_x += ((WORD *)tf->tf_CharSpace)[idx];
961 else
962 current_x += tf->tf_XSize; /* Add glyph width */
963
964 current_x += rp->TxSpacing;
965
966 string ++;
967 } /* for (each character to render) */
968
969 Move(rp, current_x, rp->cp_y);
970
971 if (NULL != rp->Layer)
972 UnlockLayerRom(rp->Layer);
973
974 RELEASE_DRIVERDATA(rp, GfxBase);
975
976 return;
977
978 }
979
980 /***********************************************/
981 /* CYBERGFX CALLS ***/
982
983
984 struct wpa_render_data
985 {
986 UBYTE *array;
987 HIDDT_StdPixFmt pixfmt;
988 ULONG modulo;
989 ULONG bppix;
990 };
991
992 static ULONG wpa_render(APTR wpar_data
993 , LONG srcx, LONG srcy
994 , OOP_Object *dstbm_obj
995 , OOP_Object *dst_gc
996 , LONG x1, LONG y1, LONG x2, LONG y2
997 , struct GfxBase *GfxBase)
998 {
999 struct wpa_render_data *wpard;
1000 ULONG width, height;
1001 UBYTE *array;
1002
1003 width = x2 - x1 + 1;
1004 height = y2 - y1 + 1;
1005
1006 wpard = (struct wpa_render_data *)wpar_data;
1007
1008 array = wpard->array + wpard->modulo * srcy + wpard->bppix * srcx;
1009
1010 HIDD_BM_PutImage(dstbm_obj
1011 , dst_gc, array
1012 , wpard->modulo
1013 , x1, y1
1014 , width, height
1015 , wpard->pixfmt
1016 );
1017
1018 return width * height;
1019 }
1020
1021 struct wpaa_render_data
1022 {
1023 UBYTE *array;
1024 ULONG modulo;
1025 };
1026
1027 static ULONG wpaa_render(APTR wpaar_data
1028 , LONG srcx, LONG srcy
1029 , OOP_Object *dstbm_obj
1030 , OOP_Object *dst_gc
1031 , LONG x1, LONG y1, LONG x2, LONG y2
1032 , struct GfxBase *GfxBase)
1033 {
1034 struct wpaa_render_data *wpaard;
1035 ULONG width, height;
1036 UBYTE *array;
1037
1038 width = x2 - x1 + 1;
1039 height = y2 - y1 + 1;
1040
1041 wpaard = (struct wpaa_render_data *)wpaar_data;
1042
1043 array = wpaard->array + wpaard->modulo * srcy + 4 * srcx;
1044
1045 HIDD_BM_PutAlphaImage(dstbm_obj
1046 , dst_gc, array
1047 , wpaard->modulo
1048 , x1, y1
1049 , width, height
1050 );
1051
1052 return width * height;
1053 }
1054
1055 struct bta_render_data
1056 {
1057 UBYTE *array;
1058 ULONG modulo;
1059 UBYTE invertalpha;
1060 };
1061
1062 static ULONG bta_render(APTR bta_data
1063 , LONG srcx, LONG srcy
1064 , OOP_Object *dstbm_obj
1065 , OOP_Object *dst_gc
1066 , LONG x1, LONG y1, LONG x2, LONG y2
1067 , struct GfxBase *GfxBase)
1068 {
1069 struct bta_render_data *btard;
1070 ULONG width, height;
1071 UBYTE *array;
1072
1073 width = x2 - x1 + 1;
1074 height = y2 - y1 + 1;
1075
1076 btard = (struct bta_render_data *)bta_data;
1077
1078 array = btard->array + btard->modulo * srcy + srcx;
1079
1080 HIDD_BM_PutAlphaTemplate(dstbm_obj
1081 , dst_gc, array
1082 , btard->modulo
1083 , x1, y1
1084 , width, height
1085 , btard->invertalpha
1086 );
1087
1088 return width * height;
1089 }
1090
1091 struct rpa_render_data {
1092 UBYTE *array;
1093 HIDDT_StdPixFmt pixfmt;
1094 ULONG modulo;
1095 ULONG bppix;
1096 };
1097
1098 static ULONG rpa_render(APTR rpar_data
1099 , LONG srcx, LONG srcy
1100 , OOP_Object *dstbm_obj
1101 , OOP_Object *dst_gc
1102 , LONG x1, LONG y1, LONG x2, LONG y2
1103 , struct GfxBase *GfxBase)
1104 {
1105 struct rpa_render_data *rpard;
1106 ULONG width, height;
1107 UBYTE *array;
1108
1109 width = x2 - x1 + 1;
1110 height = y2 - y1 + 1;
1111
1112 rpard = (struct rpa_render_data *)rpar_data;
1113
1114 array = rpard->array + rpard->modulo * srcy + rpard->bppix * srcx;
1115
1116 HIDD_BM_GetImage(dstbm_obj
1117 , array
1118 , rpard->modulo
1119 , x1, y1
1120 , width, height
1121 , rpard->pixfmt
1122 );
1123
1124 return width * height;
1125 }
1126
1127 static LONG pix_read(APTR pr_data
1128 , OOP_Object *bm, OOP_Object *gc
1129 , LONG x, LONG y
1130 , struct GfxBase *GfxBase)
1131 {
1132 struct rgbpix_render_data *prd;
1133
1134 prd = (struct rgbpix_render_data *)pr_data;
1135
1136 prd->pixel = HIDD_BM_GetPixel(bm, x, y);
1137
1138
1139 return 0;
1140 }
1141
1142
1143 struct extcol_render_data {
1144 struct render_special_info rsi;
1145 struct BitMap *destbm;
1146 HIDDT_Pixel pixel;
1147
1148 };
1149
1150 static VOID buf_to_extcol(struct extcol_render_data *ecrd
1151 , LONG srcx, LONG srcy
1152 , LONG dstx, LONG dsty
1153 , ULONG width, ULONG height
1154 , HIDDT_Pixel *pixbuf
1155 , OOP_Object *bm_obj
1156 , HIDDT_Pixel *pixtab)
1157 {
1158 LONG y;
1159 struct BitMap *bm;
1160 bm = ecrd->destbm;
1161 for (y = 0; y < height; y ++) {
1162 LONG x;
1163
1164 for (x = 0; x < width; x ++) {
1165 if (*pixbuf ++ == ecrd->pixel) {
1166
1167 UBYTE *plane;
1168 ULONG i;
1169 /* Set the according bit in the bitmap */
1170 for (i = 0; i < bm->Depth; i ++) {
1171 plane = bm->Planes[i];
1172 if (NULL != plane) {
1173 UBYTE mask;
1174
1175 plane += COORD_TO_BYTEIDX(x + dstx, y + dsty, bm->BytesPerRow);
1176 mask = XCOORD_TO_MASK(x + dstx);
1177
1178 /* Set the pixel */
1179 *plane |= mask;
1180
1181 } /* if (plane allocated) */
1182 } /* for (plane) */
1183 } /* if (color match) */
1184 } /* for (x) */
1185 } /* for (y) */
1186
1187 return;
1188 }
1189
1190
1191
1192 static ULONG extcol_render(APTR funcdata
1193 , LONG dstx, LONG dsty
1194 , OOP_Object *dstbm_obj
1195 , OOP_Object *dst_gc
1196 , LONG x1, LONG y1, LONG x2, LONG y2
1197 , struct GfxBase *GfxBase)
1198 {
1199 /* Get the info from the hidd */
1200 struct extcol_render_data *ecrd;
1201
1202 ecrd = (struct extcol_render_data *)funcdata;
1203
1204 hidd2buf_fast(ecrd->rsi.curbm
1205 , x1, y1
1206 , (APTR)ecrd
1207 , dstx, dsty
1208 , x2 - x1 + 1
1209 , y2 - y1 + 1
1210 , buf_to_extcol
1211 , GfxBase
1212 );
1213
1214 return (x2 - x1 + 1) * (y2 - y1 + 1);
1215 }
1216
1217
1218 struct dm_message {
1219 APTR memptr;
1220 ULONG offsetx;
1221 ULONG offsety;
1222 ULONG xsize;
1223 ULONG ysize;
1224 UWORD bytesperrow;
1225 UWORD bytesperpix;
1226 UWORD colormodel;
1227
1228 };
1229
1230 struct dm_render_data {
1231 struct dm_message msg;
1232 OOP_Object *pf;
1233 struct Hook *hook;
1234 struct RastPort *rp;
1235 IPTR stdpf;
1236 OOP_Object *gc;
1237 };
1238
1239
1240 static ULONG dm_render(APTR dmr_data
1241 , LONG srcx, LONG srcy
1242 , OOP_Object *dstbm_obj
1243 , OOP_Object *dst_gc
1244 , LONG x1, LONG y1, LONG x2, LONG y2
1245 , struct GfxBase *GfxBase)
1246 {
1247 struct dm_render_data *dmrd;
1248 UBYTE *addr;
1249 struct dm_message *msg;
1250 IPTR bytesperpixel;
1251 ULONG width, height, fb_width, fb_height;
1252 ULONG banksize, memsize;
1253
1254 dmrd = (struct dm_render_data *)dmr_data;
1255 width = x2 - x1 + 1;
1256 height = y2 - y1 + 1;;
1257 msg = &dmrd->msg;
1258 #if 1
1259 msg->offsetx = x1;
1260 msg->offsety = y1;
1261 #else
1262 #warning "Not sure about this one . Set it to 0 since we adjust msg->memptr to x1/y1 lower down"
1263 msg->offsetx = 0; // x1;
1264 msg->offsety = 0; // y1;
1265 #endif
1266 msg->xsize = width;
1267 msg->ysize = height;
1268
1269 /* Get the baseadress from where to render */
1270 if (HIDD_BM_ObtainDirectAccess(dstbm_obj
1271 , &addr
1272 , &fb_height, &fb_width
1273 , &banksize, &memsize)) {
1274
1275 OOP_GetAttr(dmrd->pf, aHidd_PixFmt_BytesPerPixel, &bytesperpixel);
1276 msg->bytesperpix = (UWORD)bytesperpixel;
1277
1278 /* Colormodel allready set */
1279
1280 /* Compute the adress for the start pixel */
1281 #warning "We should maybe use something else than the BytesPerLine method since we may have alignment"
1282 msg->bytesperrow = HIDD_BM_BytesPerLine(dstbm_obj, dmrd->stdpf, width);
1283 #if 1
1284 msg->memptr = addr;
1285 #else
1286 msg->memptr = addr + (msg->bytesperrow * y1) + (bytesperpixel * x1);
1287 #endif
1288
1289 HIDD_BM_ReleaseDirectAccess(dstbm_obj);
1290
1291 CallHookPkt(dmrd->hook, dmrd->rp, msg);
1292
1293 } else {
1294 /* We are unable to gain direct access to the framebuffer,
1295 so we have to emulate it
1296 */
1297 ULONG bytesperrow;
1298 ULONG tocopy_h, max_tocopy_h;
1299 ULONG lines_todo;
1300
1301 lines_todo = height;
1302
1303 /* The HIDD bm does not have a base adress so we have to render into
1304 it using a temporary buffer
1305 */
1306 OOP_GetAttr(dmrd->pf, aHidd_PixFmt_BytesPerPixel, &bytesperpixel);
1307 //bytesperrow = HIDD_BM_BytesPerLine(dstbm_obj, dmrd->stdpf, width);
1308 bytesperrow = width * bytesperpixel;
1309
1310
1311 kprintf("width %d bytesperrow %d bytesperpixel %d\n", width, bytesperrow, bytesperpixel);
1312 kprintf(" colormodel %d\n", msg->colormodel);
1313
1314 if (PIXELBUF_SIZE < bytesperrow) {
1315 D(bug("!!! NOT ENOUGH SPACE IN TEMP BUFFER FOR A SINGLE LINE IN DoCDrawMethodTagList() !!!\n"));
1316 return 0;
1317 }
1318
1319 /* Calculate number of lines we might copy */
1320 max_tocopy_h = PIXELBUF_SIZE / bytesperrow;
1321
1322 #if 1
1323 msg->offsetx = 0;
1324 msg->offsety = 0;
1325 #endif
1326 /* Get the maximum number of lines */
1327 while (lines_todo != 0) {
1328
1329 struct TagItem gc_tags[] = {
1330 { aHidd_GC_DrawMode, vHidd_GC_DrawMode_Copy },
1331 { TAG_DONE, 0UL }
1332 };
1333
1334 IPTR old_drmd;
1335
1336 tocopy_h = MIN(lines_todo, max_tocopy_h);
1337 msg->memptr = PrivGBase(GfxBase)->pixel_buf;
1338 msg->bytesperrow = bytesperrow;
1339
1340 msg->bytesperpix = (UWORD)bytesperpixel;
1341
1342 LOCK_PIXBUF
1343 HIDD_BM_GetImage(dstbm_obj
1344 , (UBYTE *)PrivGBase(GfxBase)->pixel_buf
1345 , bytesperrow
1346 , x1, y1 + height - lines_todo, width, lines_todo
1347 , dmrd->stdpf
1348 );
1349
1350 /* Use the hook to set some pixels */
1351 CallHookPkt(dmrd->hook, dmrd->rp, msg);
1352
1353 OOP_GetAttr(dmrd->gc, aHidd_GC_DrawMode, &old_drmd);
1354 OOP_SetAttrs(dmrd->gc, gc_tags);
1355 HIDD_BM_PutImage(dstbm_obj, dmrd->gc
1356 , (UBYTE *)PrivGBase(GfxBase)->pixel_buf
1357 , bytesperrow
1358 , x1, y1 + height - lines_todo, width, lines_todo
1359 , dmrd->stdpf
1360 );
1361 gc_tags[0].ti_Data = (IPTR)old_drmd;
1362 OOP_SetAttrs(dmrd->gc, gc_tags);
1363
1364 ULOCK_PIXBUF
1365
1366 lines_todo -= tocopy_h;
1367 }
1368
1369 }
1370
1371 return width * height;
1372 }
1373
1374
1375
1376 LONG driver_WriteLUTPixelArray(APTR srcrect,
1377 UWORD srcx, UWORD srcy,
1378 UWORD srcmod, struct RastPort *rp, APTR ctable,
1379 UWORD destx, UWORD desty,
1380 UWORD sizex, UWORD sizey,
1381 UBYTE ctabformat,
1382 struct GfxBase *GfxBase)
1383 {
1384 ULONG depth;
1385
1386 HIDDT_PixelLUT pixlut;
1387 HIDDT_Pixel pixtab[256];
1388
1389 HIDDT_Color col;
1390 ULONG i;
1391
1392 LONG pixwritten = 0;
1393 UBYTE *buf;
1394
1395 /* This is cybergraphx. We only work wih HIDD bitmaps */
1396 if (!IS_HIDD_BM(rp->BitMap)) {
1397 D(bug("!!!!! Trying to use CGFX call on non-hidd bitmap in WriteLUTPixelArray()!!!\n"));
1398 return 0;
1399 }
1400
1401 pixlut.entries = 256;
1402 pixlut.pixels = pixtab;
1403
1404 depth = GetBitMapAttr(rp->BitMap, BMA_DEPTH);
1405
1406 /* This call does only support bitmaps with depth > 8. Use WritePixelArray8
1407 for other bitmaps
1408 */
1409
1410 if (depth <= 8) {
1411 D(bug("!!! TRYING TO USE WriteLUTPixelArray() ON BITMAP WITH DEPTH < 8\n"));
1412 return 0;
1413 }
1414
1415 /* Curently only one format is supported */
1416 if (CTABFMT_XRGB8 != ctabformat) {
1417 D(bug("!!! WriteLUTPixelArray() CALLED WITH UNSUPPORTED CTAB FORMAT %d\n"
1418 , ctabformat));
1419 return 0;
1420 }
1421 col.alpha = 0;
1422
1423 /* Convert the coltab into native pixels */
1424 for (i = 0; i < 256; i ++) {
1425 register ULONG rgb = ((ULONG *)ctable)[i];
1426 col.red = (HIDDT_ColComp)((rgb & 0x00FF0000) >> 8);
1427 col.green = (HIDDT_ColComp)(rgb & 0x0000FF00);
1428 col.blue = (HIDDT_ColComp)((rgb & 0x000000FF) << 8);
1429
1430 pixtab[i] = HIDD_BM_MapColor(HIDD_BM_OBJ(rp->BitMap), &col);
1431 }
1432
1433 buf = (UBYTE *)srcrect;
1434
1435 buf += CHUNKY8_COORD_TO_BYTEIDX(srcx, srcy, srcmod);
1436
1437 pixwritten = write_pixels_8(rp
1438 , buf
1439 , srcmod
1440 , destx, desty
1441 , destx + sizex - 1, desty + sizey - 1
1442 , &pixlut
1443 , GfxBase
1444 );
1445
1446
1447 /* Now blit the colors onto the screen */
1448
1449 return pixwritten;
1450 }
1451
1452
1453 LONG driver_WritePixelArray(APTR src, UWORD srcx, UWORD srcy
1454 , UWORD srcmod, struct RastPort *rp, UWORD destx, UWORD desty
1455 , UWORD width, UWORD height, UBYTE srcformat, struct GfxBase *GfxBase)
1456 {
1457
1458 OOP_Object *pf = 0;
1459 HIDDT_StdPixFmt srcfmt_hidd = 0, morphfmt_hidd = 0;
1460 ULONG start_offset;
1461 IPTR bppix;
1462
1463 LONG pixwritten = 0;
1464
1465 struct wpa_render_data wpard;
1466 struct Rectangle rr;
1467
1468 if (RECTFMT_GREY8 == srcformat)
1469 {
1470 static ULONG greytab[256];
1471
1472 /* Ignore possible race conditions during
1473 initialization. Have no bad effect. Just
1474 double initializations. */
1475
1476 /* FIXME/KILLME: evil static array which goes into BSS section
1477 which x86 native AROS regards as evil! */
1478
1479 if (greytab[255] == 0)
1480 {
1481 WORD i;
1482
1483 for(i = 0; i < 256; i++)
1484 {
1485 greytab[i] = i * 0x010101;
1486 }
1487 }
1488
1489 return driver_WriteLUTPixelArray(src, srcx, srcy, srcmod,
1490 rp, greytab, destx, desty,
1491 width, height, CTABFMT_XRGB8,
1492 GfxBase);
1493 }
1494
1495 /* This is cybergraphx. We only work wih HIDD bitmaps */
1496 if (!IS_HIDD_BM(rp->BitMap))
1497 {
1498 D(bug("!!!!! Trying to use CGFX call on non-hidd bitmap in WritePixelArray() !!!\n"));
1499 return 0;
1500 }
1501
1502 if (!OBTAIN_DRIVERDATA(rp, GfxBase))
1503 return 0;
1504
1505 if (RECTFMT_LUT8 == srcformat)
1506 {
1507
1508 HIDDT_PixelLUT pixlut = { 256, HIDD_BM_PIXTAB(rp->BitMap) };
1509 UBYTE * array = (UBYTE *)src;
1510
1511 if (rp->BitMap->Flags & BMF_SPECIALFMT)
1512 {
1513 RELEASE_DRIVERDATA(rp, GfxBase);
1514 D(bug("!!! No CLUT in driver_WritePixelArray\n"));
1515 return 0;
1516 }
1517
1518 array += CHUNKY8_COORD_TO_BYTEIDX(srcx, srcy, srcmod);
1519
1520 pixwritten = write_pixels_8(rp
1521 , array, srcmod
1522 , destx, desty
1523 , destx + width - 1, desty + height - 1
1524 , &pixlut
1525 , GfxBase);
1526
1527 RELEASE_DRIVERDATA(rp, GfxBase);
1528
1529 return pixwritten;
1530 }
1531
1532 switch (srcformat)
1533 {
1534 case RECTFMT_RGB15 : srcfmt_hidd = vHidd_StdPixFmt_RGB15 ; break;
1535 case RECTFMT_BGR15 : srcfmt_hidd = vHidd_StdPixFmt_BGR15 ; break;
1536 case RECTFMT_RGB15PC: srcfmt_hidd = vHidd_StdPixFmt_RGB15_LE; break;
1537 case RECTFMT_BGR15PC: srcfmt_hidd = vHidd_StdPixFmt_BGR15_LE; break;
1538 case RECTFMT_RGB16 : srcfmt_hidd = vHidd_StdPixFmt_RGB16 ; break;
1539 case RECTFMT_BGR16 : srcfmt_hidd = vHidd_StdPixFmt_BGR16 ; break;
1540 case RECTFMT_RGB16PC: srcfmt_hidd = vHidd_StdPixFmt_RGB16_LE; break;
1541 case RECTFMT_BGR16PC: srcfmt_hidd = vHidd_StdPixFmt_BGR16_LE; break;
1542 case RECTFMT_RGB24 : srcfmt_hidd = vHidd_StdPixFmt_RGB24 ; break;
1543 case RECTFMT_BGR24 : srcfmt_hidd = vHidd_StdPixFmt_BGR24 ; break;
1544 case RECTFMT_ARGB32 : srcfmt_hidd = vHidd_StdPixFmt_ARGB32 ; morphfmt_hidd = vHidd_StdPixFmt_0RGB32; break;
1545 case RECTFMT_BGRA32 : srcfmt_hidd = vHidd_StdPixFmt_BGRA32 ; morphfmt_hidd = vHidd_StdPixFmt_BGR032; break;
1546 case RECTFMT_RGBA32 : srcfmt_hidd = vHidd_StdPixFmt_RGBA32 ; morphfmt_hidd = vHidd_StdPixFmt_RGB032; break;
1547 case RECTFMT_ABGR32 : srcfmt_hidd = vHidd_StdPixFmt_ABGR32 ; morphfmt_hidd = vHidd_StdPixFmt_0BGR32; break;
1548 case RECTFMT_RAW : srcfmt_hidd = vHidd_StdPixFmt_Native; break;
1549 }
1550
1551 /* Compute the start of the array */
1552
1553 #warning Get rid of the below code ?
1554 /* This can be done by passing the srcx and srcy parameters on to
1555 the HIDD bitmap and let it take care of it itself.
1556 This means that HIDD_BM_PutImage() gets a lot of parameters,
1557 which may not be necessary in real life.
1558
1559 Compromise: convert from *CyberGfx* pixfmt to bppix using a table lookup.
1560 This is faster
1561 */
1562 if ((srcfmt_hidd == vHidd_StdPixFmt_Native) || (morphfmt_hidd != 0))
1563 {
1564 OOP_GetAttr(HIDD_BM_OBJ(rp->BitMap), aHidd_BitMap_PixFmt, (IPTR *)&pf);
1565 }
1566
1567 if (srcfmt_hidd != vHidd_StdPixFmt_Native)
1568 {
1569 /* RECTFMT_ARGB32 on vHidd_StdPixFmt_0RGB32 bitmap ==> use vHidd_StdPixFmt_0RGB32 */
1570 /* RECTFMT_BGRA32 on vHidd_StdPixFmt_BGR032 bitmap ==> use vHidd_StdPixFmt_BGR032 */
1571 /* RECTFMT_RGBA32 on vHidd_StdPixFmt_RGB032 bitmap ==> use vHidd_StdPixFmt_RGB032 */
1572 /* RECTFMT_ABGR32 on vHidd_StdPixFmt_0BGR32 bitmap ==> use vHidd_StdPixFmt_0BGR32 */
1573
1574 if (morphfmt_hidd != 0)
1575 {
1576 IPTR stdpf;
1577
1578 OOP_GetAttr(pf, aHidd_PixFmt_StdPixFmt, (IPTR *)&stdpf);
1579 if (stdpf == morphfmt_hidd) srcfmt_hidd = morphfmt_hidd;
1580 }
1581
1582 pf = HIDD_Gfx_GetPixFmt(SDD(GfxBase)->gfxhidd, srcfmt_hidd);
1583 }
1584
1585 OOP_GetAttr(pf, aHidd_PixFmt_BytesPerPixel, &bppix);
1586
1587 start_offset = ((ULONG)srcy) * srcmod + srcx * bppix;
1588
1589 wpard.array = ((UBYTE *)src) + start_offset;
1590 wpard.pixfmt = srcfmt_hidd;
1591 wpard.modulo = srcmod;
1592 wpard.bppix = bppix;
1593
1594 rr.MinX = destx;
1595 rr.MinY = desty;
1596 rr.MaxX = destx + width - 1;
1597 rr.MaxY = desty + height - 1;
1598
1599 pixwritten = do_render_func(rp, NULL, &rr, wpa_render, &wpard, FALSE, GfxBase);
1600
1601 RELEASE_DRIVERDATA(rp, GfxBase);
1602
1603 return pixwritten;
1604 }
1605
1606 LONG driver_WritePixelArrayAlpha(APTR src, UWORD srcx, UWORD srcy
1607 , UWORD srcmod, struct RastPort *rp, UWORD destx, UWORD desty
1608 , UWORD width, UWORD height, ULONG globalalpha, struct GfxBase *GfxBase)
1609 {
1610 ULONG start_offset;
1611 LONG pixwritten = 0;
1612 struct wpaa_render_data wpaard;
1613 struct Rectangle rr;
1614
1615 /* This is cybergraphx. We only work wih HIDD bitmaps */
1616 if (!IS_HIDD_BM(rp->BitMap))
1617 {
1618 D(bug("!!!!! Trying to use CGFX call on non-hidd bitmap in WritePixelArrayAlpha() !!!\n"));
1619 return 0;
1620 }
1621
1622 if (!OBTAIN_DRIVERDATA(rp, GfxBase))
1623 return 0;
1624
1625 /* Compute the start of the array */
1626
1627 start_offset = ((ULONG)srcy) * srcmod + srcx * 4;
1628
1629 wpaard.array = ((UBYTE *)src) + start_offset;
1630 wpaard.modulo = srcmod;
1631
1632 rr.MinX = destx;
1633 rr.MinY = desty;
1634 rr.MaxX = destx + width - 1;
1635 rr.MaxY = desty + height - 1;
1636
1637 pixwritten = do_render_func(rp, NULL, &rr, wpaa_render, &wpaard, FALSE, GfxBase);
1638
1639 RELEASE_DRIVERDATA(rp, GfxBase);
1640
1641 return pixwritten;
1642 }
1643
1644 LONG driver_ReadPixelArray(APTR dst, UWORD destx, UWORD desty
1645 , UWORD dstmod, struct RastPort *rp, UWORD srcx, UWORD srcy
1646 , UWORD width, UWORD height, UBYTE dstformat, struct GfxBase *GfxBase)
1647 {
1648
1649 OOP_Object *pf = 0;
1650 HIDDT_StdPixFmt dstfmt_hidd = 0, morphfmt_hidd = 0;
1651
1652 ULONG start_offset;
1653 IPTR bppix;
1654
1655 LONG pixread = 0;
1656 IPTR old_drmd;
1657 OOP_Object *gc;
1658
1659 struct Rectangle rr;
1660 struct rpa_render_data rpard;
1661
1662 struct TagItem gc_tags[] =
1663 {
1664 { aHidd_GC_DrawMode , vHidd_GC_DrawMode_Copy},
1665 { TAG_DONE }
1666 };
1667
1668 /* This is cybergraphx. We only work wih HIDD bitmaps */
1669 if (!IS_HIDD_BM(rp->BitMap))
1670 {
1671 D(bug("!!!!! Trying to use CGFX call on non-hidd bitmap in ReadPixelArray() !!!\n"));
1672 return 0;
1673 }
1674
1675 if (!OBTAIN_DRIVERDATA(rp, GfxBase))
1676 return 0;
1677
1678 gc = GetDriverData(rp)->dd_GC;
1679
1680 /* Preserve old drawmode */
1681 OOP_GetAttr(gc, aHidd_GC_DrawMode, &old_drmd);
1682 OOP_SetAttrs(gc, gc_tags);
1683
1684
1685 switch (dstformat)
1686 {
1687 case RECTFMT_RGB15 : dstfmt_hidd = vHidd_StdPixFmt_RGB15 ; break;
1688 case RECTFMT_BGR15 : dstfmt_hidd = vHidd_StdPixFmt_BGR15 ; break;
1689 case RECTFMT_RGB15PC: dstfmt_hidd = vHidd_StdPixFmt_RGB15_LE; break;
1690 case RECTFMT_BGR15PC: dstfmt_hidd = vHidd_StdPixFmt_BGR15_LE; break;
1691 case RECTFMT_RGB16 : dstfmt_hidd = vHidd_StdPixFmt_RGB16 ; break;
1692 case RECTFMT_BGR16 : dstfmt_hidd = vHidd_StdPixFmt_BGR16 ; break;
1693 case RECTFMT_RGB16PC: dstfmt_hidd = vHidd_StdPixFmt_RGB16_LE; break;
1694 case RECTFMT_BGR16PC: dstfmt_hidd = vHidd_StdPixFmt_BGR16_LE; break;
1695 case RECTFMT_RGB24 : dstfmt_hidd = vHidd_StdPixFmt_RGB24 ; break;
1696 case RECTFMT_BGR24 : dstfmt_hidd = vHidd_StdPixFmt_BGR24 ; break;
1697 case RECTFMT_ARGB32 : dstfmt_hidd = vHidd_StdPixFmt_ARGB32 ; morphfmt_hidd = vHidd_StdPixFmt_0RGB32; break;
1698 case RECTFMT_BGRA32 : dstfmt_hidd = vHidd_StdPixFmt_BGRA32 ; morphfmt_hidd = vHidd_StdPixFmt_BGR032; break;
1699 case RECTFMT_RGBA32 : dstfmt_hidd = vHidd_StdPixFmt_RGBA32 ; morphfmt_hidd = vHidd_StdPixFmt_RGB032; break;
1700 case RECTFMT_ABGR32 : dstfmt_hidd = vHidd_StdPixFmt_ABGR32 ; morphfmt_hidd = vHidd_StdPixFmt_0BGR32; break;
1701 case RECTFMT_RAW : dstfmt_hidd = vHidd_StdPixFmt_Native; break;
1702 }
1703
1704 #warning Get rid of the below code ?
1705 /* This can be done by passing the srcx and srcy parameters on to
1706 the HIDD bitmap and let it take care of it itself.
1707 This means that HIDD_BM_PutImage() gets a lot of parameters,
1708 which may not be necessary in real life.
1709
1710 Compromise: convert from *CyberGfx* pixfmt to bppix using a table lookup.
1711 This is faster
1712 */
1713 if ((dstfmt_hidd == vHidd_StdPixFmt_Native) || (morphfmt_hidd != 0))
1714 {
1715 OOP_GetAttr(HIDD_BM_OBJ(rp->BitMap), aHidd_BitMap_PixFmt, (IPTR *)&pf);
1716 }
1717
1718 if (dstfmt_hidd != vHidd_StdPixFmt_Native)
1719 {
1720 /* RECTFMT_ARGB32 on vHidd_StdPixFmt_0RGB32 bitmap ==> use vHidd_StdPixFmt_0RGB32 */
1721 /* RECTFMT_BGRA32 on vHidd_StdPixFmt_BGR032 bitmap ==> use vHidd_StdPixFmt_BGR032 */
1722 /* RECTFMT_RGBA32 on vHidd_StdPixFmt_RGB032 bitmap ==> use vHidd_StdPixFmt_RGB032 */
1723 /* RECTFMT_ABGR32 on vHidd_StdPixFmt_0BGR32 bitmap ==> use vHidd_StdPixFmt_0BGR32 */
1724
1725 if (morphfmt_hidd != 0)
1726 {
1727 IPTR stdpf;
1728
1729 OOP_GetAttr(pf, aHidd_PixFmt_StdPixFmt, (IPTR *)&stdpf);
1730 if (stdpf == morphfmt_hidd) dstfmt_hidd = morphfmt_hidd;
1731 }
1732
1733 pf = HIDD_Gfx_GetPixFmt(SDD(GfxBase)->gfxhidd, dstfmt_hidd);
1734 }
1735
1736 OOP_GetAttr(pf, aHidd_PixFmt_BytesPerPixel, &bppix);
1737
1738 start_offset = ((ULONG)desty) * dstmod + destx * bppix;
1739
1740 rpard.array = ((UBYTE *)dst) + start_offset;
1741 rpard.pixfmt = dstfmt_hidd;
1742 rpard.modulo = dstmod;
1743 rpard.bppix = bppix;
1744
1745 rr.MinX = srcx;
1746 rr.MinY = srcy;
1747 rr.MaxX = srcx + width - 1;
1748 rr.MaxY = srcy + height - 1;
1749
1750 pixread = do_render_func(rp, NULL, &rr, rpa_render, &rpard, FALSE, GfxBase);
1751
1752 /* restore old gc values */
1753 gc_tags[0].ti_Data = (IPTR)old_drmd;
1754 OOP_SetAttrs(gc, gc_tags);
1755
1756 RELEASE_DRIVERDATA(rp, GfxBase);
1757
1758 return pixread;
1759 }
1760
1761 LONG driver_InvertPixelArray(struct RastPort *rp
1762 , UWORD destx, UWORD desty, UWORD width, UWORD height
1763 , struct GfxBase *GfxBase)
1764 {
1765
1766 /* This is cybergraphx. We only work wih HIDD bitmaps */
1767 if (!IS_HIDD_BM(rp->BitMap))
1768 {
1769 D(bug("!!!!! Trying to use CGFX call on non-hidd bitmap InvertPixelArray() !!!\n"));
1770 return 0;
1771 }
1772
1773 return (LONG)fillrect_pendrmd(rp
1774 , destx, desty
1775 , destx + width - 1
1776 , desty + height - 1
1777 , 0xFF
1778 , vHidd_GC_DrawMode_Invert
1779 , GfxBase);
1780 }
1781
1782 LONG driver_FillPixelArray(struct RastPort *rp
1783 , UWORD destx, UWORD desty, UWORD width, UWORD height
1784 , ULONG pixel, struct GfxBase *GfxBase)
1785 {
1786 HIDDT_Color col;
1787 HIDDT_Pixel pix;
1788
1789 /* HIDDT_ColComp are 16 Bit */
1790 col.alpha = (HIDDT_ColComp)((pixel >> 16) & 0x0000FF00);
1791 col.red = (HIDDT_ColComp)((pixel >> 8) & 0x0000FF00);
1792 col.green = (HIDDT_ColComp)(pixel & 0x0000FF00);
1793 col.blue = (HIDDT_ColComp)((pixel << 8) & 0x0000FF00);
1794
1795 pix = HIDD_BM_MapColor(HIDD_BM_OBJ(rp->BitMap), &col);
1796
1797 return (LONG)fillrect_pendrmd(rp
1798 , destx, desty
1799 , destx + width - 1
1800 , desty + height - 1
1801 , pix
1802 , vHidd_GC_DrawMode_Copy
1803 , GfxBase
1804 );
1805 }
1806
1807 ULONG driver_MovePixelArray(UWORD srcx, UWORD srcy, struct RastPort *rp
1808 , UWORD destx, UWORD desty, UWORD width, UWORD height
1809 , struct GfxBase *GfxBase)
1810 {
1811 ClipBlit(rp
1812 , srcx, srcy
1813 , rp
1814 , destx, desty
1815 , width, height
1816 , 0x00C0 /* Copy */
1817 );
1818 return width * height;
1819 }
1820
1821
1822
1823 LONG driver_WriteRGBPixel(struct RastPort *rp, UWORD x, UWORD y
1824 , ULONG pixel, struct GfxBase *GfxBase)
1825 {
1826
1827 struct rgbpix_render_data prd;
1828 HIDDT_Color col;
1829 LONG retval;
1830
1831 /* This is cybergraphx. We only work wih HIDD bitmaps */
1832 if (!IS_HIDD_BM(rp->BitMap))
1833 {
1834 D(bug("!!!!! Trying to use CGFX call on non-hidd bitmap in WriteRGBPixel() !!!\n"));
1835 return 0;
1836 }
1837
1838 if (!OBTAIN_DRIVERDATA(rp, GfxBase)) return -1;
1839
1840 /* HIDDT_ColComp are 16 Bit */
1841
1842 col.alpha = (HIDDT_ColComp)((pixel >> 16) & 0x0000FF00);
1843 col.red = (HIDDT_ColComp)((pixel >> 8) & 0x0000FF00);
1844 col.green = (HIDDT_ColComp)(pixel & 0x0000FF00);
1845 col.blue = (HIDDT_ColComp)((pixel << 8) & 0x0000FF00);
1846
1847 prd.pixel = HIDD_BM_MapColor(HIDD_BM_OBJ(rp->BitMap), &col);
1848
1849 retval = do_pixel_func(rp, x, y, rgbpix_write, &prd, GfxBase);
1850
1851 RELEASE_DRIVERDATA(rp, GfxBase);
1852
1853 return retval;
1854
1855 }
1856
1857
1858 ULONG driver_ReadRGBPixel(struct RastPort *rp, UWORD x, UWORD y
1859 , struct GfxBase *GfxBase)
1860 {
1861 struct rgbpix_render_data prd;
1862
1863 /* Get the HIDD pixel val */
1864 HIDDT_Color col;
1865 HIDDT_Pixel pix;
1866 LONG ret;
1867
1868 /* This is cybergraphx. We only work wih HIDD bitmaps */
1869 if (!IS_HIDD_BM(rp->BitMap))
1870 {
1871 D(bug("!!!!! Trying to use CGFX call on non-hidd bitmap in ReadRGBPixel()!!!\n"));
1872 return (ULONG)-1;
1873 }
1874
1875 if (!OBTAIN_DRIVERDATA(rp, GfxBase)) return (ULONG)-1;
1876
1877 ret = do_pixel_func(rp, x, y, pix_read, &prd, GfxBase);
1878
1879 RELEASE_DRIVERDATA(rp, GfxBase);
1880
1881 if (-1 == ret)
1882 return (ULONG)-1;
1883
1884 HIDD_BM_UnmapPixel(HIDD_BM_OBJ(rp->BitMap), prd.pixel, &col);
1885
1886 /* HIDDT_ColComp are 16 Bit */
1887
1888 pix = ((col.alpha & 0xFF00) << 16)
1889 | ((col.red & 0xFF00) << 8)
1890 | (col.green & 0xFF00)
1891 | ((col.blue & 0xFF00) >> 8);
1892
1893 return pix;
1894 }
1895
1896
1897
1898 ULONG driver_GetCyberMapAttr(struct BitMap *bitMap, ULONG attribute, struct GfxBase *GfxBase)
1899 {
1900 OOP_Object *bm_obj;
1901 OOP_Object *pf;
1902
1903 IPTR retval;
1904
1905 /* This is cybergraphx. We only work wih HIDD bitmaps */
1906 if (!IS_HIDD_BM(bitMap)) {
1907 D(bug("!!!!! Trying to use CGFX call on non-hidd bitmap in GetCyberMapAttr() !!!\n"));
1908 return 0;
1909 }
1910
1911 bm_obj = HIDD_BM_OBJ(bitMap);
1912
1913 OOP_GetAttr(bm_obj, aHidd_BitMap_PixFmt, (IPTR *)&pf);
1914
1915 switch (attribute) {
1916 case CYBRMATTR_XMOD:
1917 OOP_GetAttr(bm_obj, aHidd_BitMap_BytesPerRow, &retval);
1918 break;
1919
1920 case CYBRMATTR_BPPIX:
1921 OOP_GetAttr(pf, aHidd_PixFmt_BytesPerPixel, &retval);
1922 break;
1923
1924 case CYBRMATTR_PIXFMT: {
1925 IPTR stdpf;
1926 UWORD cpf;
1927 OOP_GetAttr(pf, aHidd_PixFmt_StdPixFmt, (IPTR *)&stdpf);
1928
1929 /* Convert to cybergfx */
1930 cpf = hidd2cyber_pixfmt(stdpf, GfxBase);
1931
1932 if (cpf == (UWORD)-1) {
1933 D(bug("!!! UNKNOWN PIXEL FORMAT IN GetCyberMapAttr()\n"));
1934 }
1935
1936 retval = (IPTR)cpf;
1937 break;
1938
1939 }
1940
1941 case CYBRMATTR_WIDTH:
1942 #if 0 /* stegerg: doesn't really work, because of framebuffer bitmap object stuff */
1943 OOP_GetAttr(bm_obj, aHidd_BitMap_Width, &retval);
1944 #else
1945 retval = GetBitMapAttr(bitMap, BMA_WIDTH);
1946 #endif
1947 break;
1948
1949 case CYBRMATTR_HEIGHT:
1950 #if 0 /* stegerg: doesn't really work, because of framebuffer bitmap object stuff */
1951 OOP_GetAttr(bm_obj, aHidd_BitMap_Height, &retval);
1952 #else
1953 retval = GetBitMapAttr(bitMap, BMA_HEIGHT);
1954 #endif
1955 break;
1956
1957 case CYBRMATTR_DEPTH:
1958 #if 0 /* stegerg: might not really work, because of framebuffer bitmap object stuff */
1959 OOP_GetAttr(pf, aHidd_PixFmt_Depth, &retval);
1960 #else
1961 retval = GetBitMapAttr(bitMap, BMA_DEPTH);
1962 #endif
1963 break;
1964
1965 case CYBRMATTR_ISCYBERGFX: {
1966 IPTR depth;
1967
1968 OOP_GetAttr(pf, aHidd_PixFmt_Depth, &depth);
1969
1970 if (depth < 8) {
1971 retval = 0;
1972 } else {
1973 /* We allways have a HIDD bitmap */
1974 retval = 0xFFFFFFFF; /* Some apps seem to rely on this retval */
1975 }
1976 break; }
1977
1978 case CYBRMATTR_ISLINEARMEM:
1979 OOP_GetAttr(bm_obj, aHidd_BitMap_IsLinearMem, &retval);
1980 break;
1981
1982 default:
1983 D(bug("!!! UNKNOWN ATTRIBUTE PASSED TO GetCyberMapAttr()\n"));
1984 break;
1985
1986
1987 } /* switch (attribute) */
1988
1989 return retval;
1990 }
1991
1992
1993 VOID driver_CVideoCtrlTagList(struct ViewPort *vp, struct TagItem *tags, struct GfxBase *GfxBase)
1994 {
1995 struct TagItem *tag, *tstate;
1996 ULONG dpmslevel = 0;
1997
1998 struct TagItem htags[] =
1999 {
2000 { aHidd_Gfx_DPMSLevel, 0UL },
2001 { TAG_DONE, 0UL }
2002 };
2003
2004 BOOL dpms_found = FALSE;
2005
2006 HIDDT_DPMSLevel hdpms = 0;
2007
2008 for (tstate = tags; (tag = NextTagItem((const struct TagItem **)&tstate)); )
2009 {
2010 switch (tag->ti_Tag)
2011 {
2012 case SETVC_DPMSLevel:
2013 dpmslevel = tag->ti_Data;
2014 dpms_found = TRUE;
2015 break;
2016
2017 default:
2018 D(bug("!!! UNKNOWN TAG IN CVideoCtrlTagList(): %x !!!\n"
2019 , tag->ti_Tag));
2020 break;
2021
2022 } /* switch() */
2023
2024 } /* for (each tagitem) */
2025
2026
2027 if (dpms_found)
2028 {
2029
2030 /* Convert to hidd dpms level */
2031 switch (dpmslevel)
2032 {
2033 case DPMS_ON:
2034 hdpms = vHidd_Gfx_DPMSLevel_On;
2035 break;
2036
2037 case DPMS_STANDBY:
2038 hdpms = vHidd_Gfx_DPMSLevel_Standby;
2039 break;
2040
2041 case DPMS_SUSPEND:
2042 hdpms = vHidd_Gfx_DPMSLevel_Suspend;
2043 break;
2044
2045 case DPMS_OFF:
2046 hdpms = vHidd_Gfx_DPMSLevel_Off;
2047 break;
2048
2049 default:
2050 D(bug("!!! UNKNOWN DPMS LEVEL IN CVideoCtrlTagList(): %x !!!\n"
2051 , dpmslevel));
2052
2053 dpms_found = FALSE;
2054 break;
2055
2056 }
2057 }
2058
2059 if (dpms_found)
2060 {
2061 htags[0].ti_Data = hdpms;
2062 }
2063 else
2064 {
2065 htags[0].ti_Tag = TAG_IGNORE;
2066 }
2067
2068 OOP_SetAttrs(SDD(GfxBase)->gfxhidd, htags);
2069
2070 return;
2071 }
2072
2073
2074 ULONG driver_ExtractColor(struct RastPort *rp, struct BitMap *bm
2075 , ULONG color, ULONG srcx, ULONG srcy, ULONG width, ULONG height
2076 , struct GfxBase *GfxBase)
2077 {
2078 struct Rectangle rr;
2079 LONG pixread = 0;
2080 struct extcol_render_data ecrd;
2081 OOP_Object *pf;
2082 IPTR colmod;
2083
2084 if (!IS_HIDD_BM(rp->BitMap))
2085 {
2086 D(bug("!!! CALLING ExtractColor() ON NO-HIDD BITMAP !!!\n"));
2087 return FALSE;
2088 }
2089
2090 if (!OBTAIN_DRIVERDATA(rp, GfxBase))
2091 return FALSE;
2092
2093 rr.MinX = srcx;
2094 rr.MinY = srcy;
2095 rr.MaxX = srcx + width - 1;
2096 rr.MaxY = srcy + height - 1;
2097
2098 OOP_GetAttr(HIDD_BM_OBJ(rp->BitMap), aHidd_BitMap_PixFmt, (IPTR *)&pf);
2099
2100 OOP_GetAttr(pf, aHidd_PixFmt_ColorModel, (IPTR *)&colmod);
2101
2102 if (vHidd_ColorModel_Palette == colmod)
2103 {
2104 ecrd.pixel = color;
2105 }
2106 else
2107 {
2108 HIDDT_Color col;
2109
2110 col.alpha = (color >> 16) & 0x0000FF00;
2111 col.red = (color >> 8 ) & 0x0000FF00;
2112 col.green = color & 0x0000FF00;
2113 col.blue = (color << 8) & 0x0000FF00;
2114
2115 ecrd.pixel = HIDD_BM_MapColor(HIDD_BM_OBJ(rp->BitMap), &col);
2116
2117 }
2118
2119 ecrd.destbm = bm;
2120
2121 pixread = do_render_func(rp, NULL, &rr, extcol_render, NULL, TRUE, GfxBase);
2122
2123 RELEASE_DRIVERDATA(rp, GfxBase);
2124
2125 if (pixread != (width * height))
2126 return FALSE;
2127
2128 return TRUE;
2129 }
2130
2131
2132 VOID driver_DoCDrawMethodTagList(struct Hook *hook, struct RastPort *rp, struct TagItem *tags, struct GfxBase *GfxBase)
2133 {
2134
2135 struct dm_render_data dmrd;
2136 struct Rectangle rr;
2137 struct Layer *L;
2138
2139 if (!IS_HIDD_BM(rp->BitMap))
2140 {
2141 D(bug("!!! NO HIDD BITMAP IN CALL TO DoCDrawMethodTagList() !!!\n"));
2142 return;
2143 }
2144
2145 if (!OBTAIN_DRIVERDATA(rp, GfxBase))
2146 return;
2147
2148 /* Get the bitmap std pixfmt */
2149 OOP_GetAttr(HIDD_BM_OBJ(rp->BitMap), aHidd_BitMap_PixFmt, (IPTR *)&dmrd.pf);
2150 OOP_GetAttr(dmrd.pf, aHidd_PixFmt_StdPixFmt, &dmrd.stdpf);
2151 dmrd.msg.colormodel = hidd2cyber_pixfmt(dmrd.stdpf, GfxBase);
2152 dmrd.hook = hook;
2153 dmrd.rp = rp;
2154
2155 if (((UWORD)-1) == dmrd.msg.colormodel)
2156 {
2157 RELEASE_DRIVERDATA(rp, GfxBase);
2158 D(bug("!!! UNKNOWN HIDD PIXFMT IN DoCDrawMethodTagList() !!!\n"));
2159 return;
2160 }
2161
2162
2163 L = rp->Layer;
2164
2165 rr.MinX = 0;
2166 rr.MinY = 0;
2167
2168 if (NULL == L)
2169 {
2170 rr.MaxX = GetBitMapAttr(rp->BitMap, BMA_WIDTH) - 1;
2171 rr.MaxY = GetBitMapAttr(rp->BitMap, BMA_HEIGHT) - 1;
2172 }
2173 else
2174 {
2175 /* Lock the layer */
2176 LockLayerRom(L);
2177
2178 rr.MaxX = rr.MinX + (L->bounds.MaxX - L->bounds.MinX) - 1;
2179 rr.MaxY = rr.MinY + (L->bounds.MaxY - L->bounds.MinY) - 1;
2180 }
2181
2182 dmrd.gc = GetDriverData(rp)->dd_GC;
2183 do_render_func(rp, NULL, &rr, dm_render, &dmrd, FALSE, GfxBase);
2184
2185 RELEASE_DRIVERDATA(rp, GfxBase);
2186
2187 if (NULL != L)
2188 {
2189 UnlockLayerRom(L);
2190 }
2191
2192 return;
2193 }
2194
2195 APTR driver_LockBitMapTagList(struct BitMap *bm, struct TagItem *tags, struct GfxBase *GfxBase)
2196 {
2197 struct TagItem *tag;
2198 UBYTE *baseaddress;
2199 ULONG width, height, banksize, memsize;
2200 OOP_Object *pf;
2201 IPTR stdpf;
2202 UWORD cpf;
2203
2204 if (!IS_HIDD_BM(bm))
2205 {
2206 D(bug("!!! TRYING TO CALL LockBitMapTagList() ON NON-HIDD BM !!!\n"));
2207 return NULL;
2208 }
2209
2210 OOP_GetAttr(HIDD_BM_OBJ(bm), aHidd_BitMap_PixFmt, (IPTR *)&pf);
2211
2212 OOP_GetAttr(pf, aHidd_PixFmt_StdPixFmt, &stdpf);
2213 cpf = hidd2cyber_pixfmt(stdpf, GfxBase);
2214 if (((UWORD)-1) == cpf)
2215 {
2216 D(bug("!!! TRYING TO CALL LockBitMapTagList() ON NON-CYBER PIXFMT BITMAP !!!\n"));
2217 return NULL;
2218 }
2219
2220 /* Get some info from the bitmap object */
2221 if (!HIDD_BM_ObtainDirectAccess(HIDD_BM_OBJ(bm), &baseaddress, &width, &height, &banksize, &memsize))
2222 return NULL;
2223
2224
2225 while ((tag = NextTagItem((const struct TagItem **)&tags)))
2226 {
2227 switch (tag->ti_Tag)
2228 {
2229 case LBMI_BASEADDRESS:
2230 *((IPTR **)tag->ti_Data) = (IPTR *)baseaddress;
2231 break;
2232
2233 case LBMI_BYTESPERROW:
2234 *((IPTR *)tag->ti_Data) =
2235 (ULONG)HIDD_BM_BytesPerLine(HIDD_BM_OBJ(bm), stdpf, width);
2236 break;
2237
2238 case LBMI_BYTESPERPIX:
2239 OOP_GetAttr(pf, aHidd_PixFmt_BytesPerPixel, (IPTR *)tag->ti_Data);
2240 break;
2241
2242 case LBMI_PIXFMT:
2243 *((IPTR *)tag->ti_Data) = (IPTR)cpf;
2244 break;
2245
2246 case LBMI_DEPTH:
2247 OOP_GetAttr(pf, aHidd_PixFmt_Depth, (IPTR *)tag->ti_Data);
2248 break;
2249
2250 case LBMI_WIDTH:
2251 OOP_GetAttr(HIDD_BM_OBJ(bm), aHidd_BitMap_Width, (IPTR *)tag->ti_Data);
2252 break;
2253
2254 case LBMI_HEIGHT:
2255 OOP_GetAttr(HIDD_BM_OBJ(bm), aHidd_BitMap_Height, (IPTR *)tag->ti_Data);
2256 break;
2257
2258 default:
2259 D(bug("!!! UNKNOWN TAG PASSED TO LockBitMapTagList() !!!\n"));
2260 break;
2261 }
2262 }
2263
2264 return HIDD_BM_OBJ(bm);
2265 }
2266
2267 VOID driver_UnLockBitMap(APTR handle, struct GfxBase *GfxBase)
2268 {
2269 if (handle) HIDD_BM_ReleaseDirectAccess((OOP_Object *)handle);
2270 }
2271
2272 VOID driver_UnLockBitMapTagList(APTR handle, struct TagItem *tags, struct GfxBase *GfxBase)
2273 {
2274 struct TagItem *tag;
2275 BOOL reallyunlock = TRUE;
2276
2277 while ((tag = NextTagItem((const struct TagItem **)&tags)))
2278 {
2279 switch (tag->ti_Tag)
2280 {
2281 case UBMI_REALLYUNLOCK:
2282 reallyunlock = (BOOL)tag->ti_Data;
2283 break;
2284
2285 case UBMI_UPDATERECTS:
2286 {
2287 struct RectList *rl;
2288
2289 rl = (struct RectList *)tag->ti_Data;
2290
2291 #warning Dunno what to do with this
2292
2293 break;
2294 }
2295
2296 default:
2297 D(bug("!!! UNKNOWN TAG PASSED TO UnLockBitMapTagList() !!!\n"));
2298 break;
2299 }
2300 }
2301
2302 if (reallyunlock)
2303 {
2304 HIDD_BM_ReleaseDirectAccess((OOP_Object *)handle);
2305 }
2306 }
2307
2308 void driver_BltTemplateAlpha(UBYTE *src, LONG srcx, LONG srcmod
2309 , struct RastPort *rp, LONG destx, LONG desty, LONG width, LONG height
2310 , struct GfxBase *GfxBase)
2311 {
2312 struct bta_render_data btard;
2313 struct Rectangle rr;
2314
2315 /* This is cybergraphx. We only work wih HIDD bitmaps */
2316 if (!IS_HIDD_BM(rp->BitMap)) {
2317 D(bug("!!!!! Trying to use CGFX call on non-hidd bitmap in BltTemplateAlpha() !!!\n"));
2318 return;
2319 }
2320
2321 if (!OBTAIN_DRIVERDATA(rp, GfxBase))
2322 return;
2323
2324 /* Compute the start of the array */
2325
2326 btard.array = src + srcx;
2327 btard.modulo = srcmod;
2328 btard.invertalpha = (rp->DrawMode & INVERSVID) ? TRUE : FALSE;
2329 rr.MinX = destx;
2330 rr.MinY = desty;
2331 rr.MaxX = destx + width - 1;
2332 rr.MaxY = desty + height - 1;
2333
2334 do_render_func(rp, NULL, &rr, bta_render, &btard, FALSE, GfxBase);
2335
2336 RELEASE_DRIVERDATA(rp, GfxBase);
2337 }
2338
2339 /******************************************/
2340 /* Support stuff for cybergfx */
2341 /******************************************/
2342
2343 #undef GfxBase
2344
A totally sweet operating system