?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
uaegfx.hidd: Compiler delint
[AROS.git] / arch / m68k-amiga / hidd / uaegfx / uaegfx.c
blobd22db0b909f36c41592ab530edb7e101860eaa13
1 /*
2 Copyright 1995-2010, The AROS Development Team. All rights reserved.
3 $Id$
4
5 Desc:
6 Lang: English.
7 */
8
9 #include <exec/libraries.h>
10 #include <exec/rawfmt.h>
11 #include <exec/types.h>
12 #include <exec/resident.h>
13 #include <exec/memory.h>
14 #include <graphics/displayinfo.h>
15 #include <intuition/intuitionbase.h>
16 #include <aros/libcall.h>
17 #include <proto/alib.h>
18 #include <proto/exec.h>
19 #include <proto/kernel.h>
20 #include <proto/oop.h>
21 #include <proto/utility.h>
22 #include <oop/oop.h>
23
24 #include <hidd/hidd.h>
25 #include <hidd/graphics.h>
26
27 #include <aros/symbolsets.h>
28
29 #include LC_LIBDEFS_FILE
30
31 #include "uaegfx.h"
32 #include "uaegfxbitmap.h"
33 #include "uaertg.h"
34
35 #define SDEBUG 0
36 #define DEBUG 0
37 #define DRTG(x) x;
38 #include <aros/debug.h>
39
40 #define SIZE_RESLIST 5
41 #define SIZE_PFLIST 19
42 #define SIZE_MODELIST (5 + RGBFB_MaxFormats)
43
44 HIDDT_ModeID *UAEGFXCl__Hidd_Gfx__QueryModeIDs(OOP_Class *cl, OOP_Object *o, struct pHidd_Gfx_QueryModeIDs *msg)
45 {
46 struct uaegfx_staticdata *csd = CSD(cl);
47 struct RTGMode *node;
48 struct TagItem *tag, *tstate;
49 ULONG minwidth = 0, maxwidth = 0xFFFFFFFF;
50 ULONG minheight = 0, maxheight = 0xFFFFFFFF;
51 OOP_Object **pf = NULL;
52 HIDDT_ModeID *modeids;
53 WORD cnt;
54
55 if (csd->superforward)
56 return (HIDDT_ModeID*)OOP_DoSuperMethod(cl, o, (OOP_Msg)msg);
57
58 for (tstate = msg->queryTags; (tag = NextTagItem((const struct TagItem **)&tstate)); )
59 {
60 switch (tag->ti_Tag)
61 {
62 case tHidd_GfxMode_MinWidth:
63 minwidth = (ULONG)tag->ti_Tag;
64 break;
65
66 case tHidd_GfxMode_MaxWidth:
67 maxwidth = (ULONG)tag->ti_Tag;
68 break;
69
70 case tHidd_GfxMode_MinHeight:
71 minheight = (ULONG)tag->ti_Tag;
72 break;
73
74 case tHidd_GfxMode_MaxHeight:
75 maxheight = (ULONG)tag->ti_Tag;
76 break;
77
78 case tHidd_GfxMode_PixFmts:
79 pf = (OOP_Object**)tag->ti_Tag;
80 break;
81
82 }
83 }
84 DB2(bug("QueryModeIDs (%dx%d)-(%dx%d) %p\n", minwidth, minheight, maxwidth, maxheight, pf));
85 cnt = 0;
86 ForeachNode(&csd->rtglist, node) {
87 if (node->width >= minwidth && node->width <= maxwidth && node->height >= minheight && node->height <= maxheight) {
88 OOP_Object **pfp = NULL;
89 if (pf) {
90 pfp = pf;
91 while (*pfp) {
92 if (*pfp == node->pf) {
93 pfp = NULL;
94 break;
95 }
96 pfp++;
97 }
98 }
99 if (!pfp)
100 cnt++;
101 }
102 }
103 modeids = AllocVec((cnt + 1) * sizeof(HIDDT_ModeID), MEMF_PUBLIC);
104 if (!modeids)
105 return NULL;
106 cnt = 0;
107 ForeachNode(&csd->rtglist, node) {
108 if (node->width >= minwidth && node->width <= maxwidth && node->height >= minheight && node->height <= maxheight) {
109 OOP_Object **pfp = NULL;
110 if (pf) {
111 pfp = pf;
112 while (*pfp) {
113 if (*pfp == node->pf) {
114 pfp = NULL;
115 break;
116 }
117 pfp++;
118 }
119 }
120 if (!pfp) {
121 DB2(bug("%d: %08x\n", cnt, node->modeid));
122 modeids[cnt++] = node->modeid;
123 }
124 }
125 }
126 modeids[cnt] = vHidd_ModeID_Invalid;
127 return modeids;
128 }
129
130 VOID UAEGFXCl__Hidd_Gfx__ReleaseModeIDs(OOP_Class *cl, OOP_Object *o, struct pHidd_Gfx_ReleaseModeIDs *msg)
131 {
132 struct uaegfx_staticdata *csd = CSD(cl);
133 if (csd->superforward)
134 OOP_DoSuperMethod(cl, o, (OOP_Msg)msg);
135 else
136 FreeVec(msg->modeIDs);
137 }
138
139 HIDDT_ModeID UAEGFXCl__Hidd_Gfx__NextModeID(OOP_Class *cl, OOP_Object *o, struct pHidd_Gfx_NextModeID *msg)
140 {
141 struct uaegfx_staticdata *csd = CSD(cl);
142 struct RTGMode *node = NULL;
143 HIDDT_ModeID mid = vHidd_ModeID_Invalid;
144
145 DB2(bug("NextModeID %08x\n", msg->modeID));
146 if (msg->modeID != vHidd_ModeID_Invalid) {
147 ForeachNode(&csd->rtglist, node) {
148 if (node->modeid == msg->modeID) {
149 node = (struct RTGMode*)node->node.ln_Succ;
150 break;
151 }
152 }
153 }
154 if (!node)
155 node = (struct RTGMode*)csd->rtglist.lh_Head;
156 if (node->node.ln_Succ) {
157 mid = node->modeid;
158 *msg->syncPtr = node->sync;
159 *msg->pixFmtPtr = node->pf;
160 }
161 DB2(bug("=%08x %p %p\n", mid, *msg->syncPtr, *msg->pixFmtPtr));
162 return mid;
163 }
164
165 BOOL UAEGFXCl__Hidd_Gfx__GetMode(OOP_Class *cl, OOP_Object *o, struct pHidd_Gfx_GetMode *msg)
166 {
167 struct uaegfx_staticdata *csd = CSD(cl);
168 struct RTGMode *node;
169
170 if (csd->superforward)
171 return (BOOL)OOP_DoSuperMethod(cl, o, (OOP_Msg)msg);
172
173 DB2(bug("GetMode %08x\n", msg->modeID));
174 ForeachNode(&csd->rtglist, node) {
175 if (node->modeid == msg->modeID) {
176 *msg->syncPtr = node->sync;
177 *msg->pixFmtPtr = node->pf;
178 DB2(bug("= %p %p\n", node->sync, node->pf));
179 return TRUE;
180 }
181 }
182 DB2(bug("= FAIL\n"));
183 return FALSE;
184 }
185
186 struct RTGFormat
187 {
188 UWORD rgbformat;
189 ULONG rm, gm, bm, am;
190 UWORD rs, gs, bs, as;
191 BOOL endianswap;
192 };
193
194 static const struct RTGFormat formats[] =
195 {
196 { RGBFB_CLUT, 0x00ff0000, 0x0000ff00, 0x000000ff, 0x00000000, 8, 16, 24, 0, FALSE },
197
198 { RGBFB_B8G8R8A8, 0x0000ff00, 0x00ff0000, 0xff000000, 0x000000ff, 16, 8, 0, 24, FALSE },
199 { RGBFB_R8G8B8A8, 0xff000000, 0x00ff0000, 0x0000ff00, 0x000000ff, 0, 8, 16, 24, FALSE },
200 { RGBFB_A8B8G8R8, 0x000000ff, 0x0000ff00, 0x00ff0000, 0xff000000, 24, 16, 8, 0, FALSE },
201 { RGBFB_A8R8G8B8, 0x00ff0000, 0x0000ff00, 0x000000ff, 0xff000000, 8, 16, 24, 0, FALSE },
202
203 { RGBFB_B8G8R8, 0x000000ff, 0x0000ff00, 0x00ff0000, 0x00000000, 24, 16, 8, 0, FALSE },
204 { RGBFB_R8G8B8, 0x00ff0000, 0x0000ff00, 0x000000ff, 0x00000000, 8, 16, 24, 0, FALSE },
205
206 { RGBFB_R5G5B5PC, 0x00007c00, 0x000003e0, 0x0000001f, 0x00000000, 17, 22, 27, 0, TRUE },
207 { RGBFB_R5G6B5PC, 0x0000f800, 0x000007e0, 0x0000001f, 0x00000000, 16, 21, 27, 0, TRUE },
208 { RGBFB_R5G5B5, 0x00007c00, 0x000003e0, 0x0000001f, 0x00000000, 17, 22, 27, 0, FALSE },
209 { RGBFB_R5G6B5, 0x0000f800, 0x000007e0, 0x0000001f, 0x00000000, 16, 21, 27, 0, FALSE },
210 /*
211 { RGBFB_B5G5R5PC, 0x0000003e, 0x000007c0, 0x0000f800, 0x00000000, 26, 21, 16, 0, TRUE },
212 { RGBFB_B5G6R5PC, 0x0000001f, 0x000007e0, 0x0000f800, 0x00000000, 27, 21, 16, 0, TRUE },
213 */
214 { 0 }
215 };
216
217 static const UBYTE rgbtypelist[] = {
218 RGBFB_CLUT,
219
220 RGBFB_R5G6B5PC,
221 RGBFB_R5G5B5PC,
222 RGBFB_B5G6R5PC,
223 RGBFB_B5G5R5PC,
224 RGBFB_R5G6B5,
225 RGBFB_R5G5B5,
226
227 RGBFB_B8G8R8,
228 RGBFB_R8G8B8,
229
230 RGBFB_B8G8R8A8,
231 RGBFB_A8B8G8R8,
232 RGBFB_A8R8G8B8,
233 RGBFB_R8G8B8A8,
234 0
235 };
236
237 OOP_Object *UAEGFXCl__Root__New(OOP_Class *cl, OOP_Object *o, struct pRoot_New *msg)
238 {
239 struct uaegfx_staticdata *csd = CSD(cl);
240 struct Library *OOPBase = csd->cs_OOPBase;
241 struct LibResolution *r;
242 WORD rescnt, i, j, k, l;
243 struct TagItem *reslist, *restags, *pflist, *modetags;
244 struct pRoot_New mymsg;
245 struct TagItem mytags[2];
246 UWORD supportedformats, gotmodes;
247
248 if (csd->initialized)
249 return NULL;
250
251 NEWLIST(&csd->rtglist);
252 NEWLIST(&csd->bitmaplist);
253 supportedformats = gw(csd->boardinfo + PSSO_BoardInfo_RGBFormats);
254 rescnt = 0;
255 ForeachNode(csd->boardinfo + PSSO_BoardInfo_ResolutionsList, r) {
256 rescnt++;
257 }
258 D(bug("UAEGFX: resolutions: %d, supportmask: %x\n", rescnt, supportedformats));
259
260 reslist = AllocVec(rescnt * SIZE_RESLIST * sizeof(struct TagItem), MEMF_PUBLIC | MEMF_CLEAR);
261 restags = AllocVec((rescnt + 1) * sizeof(struct TagItem), MEMF_PUBLIC | MEMF_CLEAR);
262 pflist = AllocVec(RGBFB_MaxFormats * SIZE_PFLIST * sizeof(struct TagItem), MEMF_PUBLIC | MEMF_CLEAR);
263 modetags = AllocVec(SIZE_MODELIST * sizeof(struct TagItem), MEMF_PUBLIC | MEMF_CLEAR);
264
265 i = 0;
266 ForeachNode(csd->boardinfo + PSSO_BoardInfo_ResolutionsList, r) {
267 reslist[i * SIZE_RESLIST + 0].ti_Tag = aHidd_Sync_HDisp;
268 reslist[i * SIZE_RESLIST + 0].ti_Data = r->Width;
269 reslist[i * SIZE_RESLIST + 1].ti_Tag = aHidd_Sync_VDisp;
270 reslist[i * SIZE_RESLIST + 1].ti_Data = r->Height;
271 reslist[i * SIZE_RESLIST + 2].ti_Tag = aHidd_Sync_Description;
272 reslist[i * SIZE_RESLIST + 2].ti_Data = (IPTR)(csd->CardBase ? "RTGFX:%hx%v" : "UAEGFX:%hx%v");
273 reslist[i * SIZE_RESLIST + 3].ti_Tag = aHidd_Sync_PixelClock;
274 reslist[i * SIZE_RESLIST + 3].ti_Data = r->Modes[CHUNKY]->PixelClock;
275 reslist[i * SIZE_RESLIST + 4].ti_Tag = TAG_DONE;
276 reslist[i * SIZE_RESLIST + 4].ti_Data = 0;
277 D(bug("%08x %d*%d\n", r, r->Width, r->Height));
278 restags[i].ti_Tag = aHidd_Gfx_SyncTags;
279 restags[i].ti_Data = (IPTR)&reslist[i * SIZE_RESLIST];
280 i++;
281 }
282 restags[i].ti_Tag = TAG_DONE;
283 restags[i].ti_Data = 0;
284
285 gotmodes = 0;
286 k = 0;
287 j = 0;
288 for (i = 0; rgbtypelist[i]; i++) {
289 UBYTE rgbtype = rgbtypelist[i];
290 WORD depth = getrtgdepth(1 << rgbtype);
291 if (!((1 << rgbtype) & RGBFB_SUPPORTMASK) || depth == 0 || !((1 << rgbtype) & supportedformats)) {
292 pflist[j].ti_Tag = TAG_DONE;
293 pflist[j].ti_Data = 0;
294 j++;
295 continue;
296 }
297 for (l = 0; formats[l].rgbformat; l++) {
298 if (formats[l].rgbformat == rgbtype)
299 break;
300 }
301 if (formats[l].rgbformat == 0) {
302 pflist[j].ti_Tag = TAG_DONE;
303 pflist[j].ti_Data = 0;
304 j++;
305 continue;
306 }
307 D(bug("RTGFORMAT=%d found. Depth=%d\n", rgbtype, depth));
308
309 if (gotmodes & (1 << (depth / 8))) {
310 D(bug("-> skipped\n"));
311 pflist[j].ti_Tag = TAG_DONE;
312 pflist[j].ti_Data = 0;
313 j++;
314 continue;
315 }
316
317 gotmodes |= 1 << (depth / 8);
318
319 modetags[k].ti_Tag = aHidd_Gfx_PixFmtTags;
320 modetags[k].ti_Data = (IPTR)&pflist[j];
321 k++;
322
323 pflist[j].ti_Tag = aHidd_PixFmt_RedShift;
324 pflist[j].ti_Data = formats[l].rs;
325 j++;
326 pflist[j].ti_Tag = aHidd_PixFmt_GreenShift;
327 pflist[j].ti_Data = formats[l].gs;
328 j++;
329 pflist[j].ti_Tag = aHidd_PixFmt_BlueShift;
330 pflist[j].ti_Data = formats[l].bs;
331 j++;
332 pflist[j].ti_Tag = aHidd_PixFmt_AlphaShift;
333 pflist[j].ti_Data = formats[l].as;
334 j++;
335 pflist[j].ti_Tag = aHidd_PixFmt_RedMask;
336 pflist[j].ti_Data = formats[l].rm;
337 j++;
338 pflist[j].ti_Tag = aHidd_PixFmt_GreenMask;
339 pflist[j].ti_Data = formats[l].gm;
340 j++;
341 pflist[j].ti_Tag = aHidd_PixFmt_BlueMask;
342 pflist[j].ti_Data = formats[l].bm;
343 j++;
344 pflist[j].ti_Tag = aHidd_PixFmt_AlphaMask;
345 pflist[j].ti_Data = formats[l].am;
346 j++;
347 pflist[j].ti_Tag = aHidd_PixFmt_CLUTMask;
348 pflist[j].ti_Data = 0x000000FF;
349 j++;
350 pflist[j].ti_Tag = aHidd_PixFmt_CLUTShift;
351 pflist[j].ti_Data = 0;
352 j++;
353 pflist[j].ti_Tag = aHidd_PixFmt_ColorModel;
354 pflist[j].ti_Data = depth <= 8 ? vHidd_ColorModel_Palette : vHidd_ColorModel_TrueColor;
355 j++;
356 pflist[j].ti_Tag = aHidd_PixFmt_Depth;
357 pflist[j].ti_Data = depth;
358 j++;
359 pflist[j].ti_Tag = aHidd_PixFmt_BytesPerPixel;
360 pflist[j].ti_Data = (depth + 7) / 8;
361 j++;
362 pflist[j].ti_Tag = aHidd_PixFmt_BitsPerPixel;
363 pflist[j].ti_Data = depth;
364 j++;
365 pflist[j].ti_Tag = aHidd_PixFmt_StdPixFmt;
366 pflist[j].ti_Data = vHidd_StdPixFmt_Native;
367 j++;
368 pflist[j].ti_Tag = aHidd_PixFmt_BitMapType;
369 pflist[j].ti_Data = vHidd_BitMapType_Chunky;
370 j++;
371 pflist[j].ti_Tag = aoHidd_PixFmt_SwapPixelBytes;
372 pflist[j].ti_Data = formats[l].endianswap;
373 j++;
374 pflist[j].ti_Tag = TAG_DONE;
375 pflist[j].ti_Data = 0;
376 j++;
377 }
378
379 modetags[k].ti_Tag = aHidd_Sync_HMin;
380 modetags[k].ti_Data = 112;
381 k++;
382 modetags[k].ti_Tag = aHidd_Sync_VMin;
383 modetags[k].ti_Data = 112;
384 k++;
385 modetags[k].ti_Tag = aHidd_Sync_HMax;
386 modetags[k].ti_Data = 16384;
387 k++;
388 modetags[k].ti_Tag = aHidd_Sync_VMax;
389 modetags[k].ti_Data = 16384;
390 k++;
391 modetags[k].ti_Tag = TAG_MORE;
392 modetags[k].ti_Data = (IPTR)restags;
393
394 mytags[0].ti_Tag = aHidd_Gfx_ModeTags;
395 mytags[0].ti_Data = (IPTR)modetags;
396 mytags[1].ti_Tag = TAG_MORE;
397 mytags[1].ti_Data = (IPTR)msg->attrList;
398
399 EnterFunc(bug("UAEGFX::New() tags=%x\n", mytags));
400
401 mymsg.mID = msg->mID;
402 mymsg.attrList = mytags;
403 msg = &mymsg;
404
405 /* Register gfxmodes */
406 o = (OOP_Object *)OOP_DoSuperMethod(cl, o, (OOP_Msg)msg);
407 if (NULL != o)
408 {
409 struct gfx_data *data = OOP_INST_DATA(cl, o);
410 HIDDT_ModeID *midp;
411
412 D(bug("UAEGFX::New(): Got object from super\n"));
413 NewList((struct List *)&data->bitmaps);
414 csd->initialized = 1;
415 csd->spritecolors = 16;
416
417 csd->superforward = TRUE;
418 midp = HIDD_Gfx_QueryModeIDs(o, NULL);
419 for (i = 0; midp[i] != vHidd_ModeID_Invalid; i++) {
420 OOP_Object *sync, *pf;
421 HIDDT_ModeID mid = midp[i];
422 IPTR dwidth, dheight;
423 struct RTGMode *node1, *node2;
424 ULONG modeid, rtgmodeid, p96mode;
425
426 if (!HIDD_Gfx_GetMode(o, mid, &sync, &pf))
427 continue;
428 OOP_GetAttr(sync, aHidd_Sync_HDisp, &dwidth);
429 OOP_GetAttr(sync, aHidd_Sync_VDisp, &dheight);
430
431 DB2(bug("w=%d h=%d mode=%08x sync=%x pf=%x\n", dwidth, dheight, mid, sync, pf));
432
433 modeid = vHidd_ModeID_Invalid;
434 ForeachNode(csd->boardinfo + PSSO_BoardInfo_ResolutionsList, r) {
435 if (r->Width == dwidth && r->Height == dheight) {
436 modeid = r->DisplayID;
437 break;
438 }
439 }
440 if (modeid == vHidd_ModeID_Invalid) {
441 D(bug("w=%d h=%d not found!\n", dwidth, dheight));
442 continue;
443 }
444
445 p96mode = getrtgformat(csd, pf);
446 rtgmodeid = (modeid & 0x00ff0000) | 0x1000 | (p96mode << 8);
447
448 ForeachNode(&csd->rtglist, node2) {
449 if (node2->width == dwidth && node2->height == dheight && node2->modeid == rtgmodeid)
450 break;
451 }
452 if (node2->node.ln_Succ != NULL) {
453 D(bug("w=%d h=%d mode=%08x already found!\n", dwidth, dheight, rtgmodeid));
454 continue;
455 }
456
457 node1 = AllocMem(sizeof(struct RTGMode), MEMF_CLEAR);
458 node1->width = dwidth;
459 node1->height = dheight;
460 node1->pf = pf;
461 node1->sync = sync;
462 node1->modeid = rtgmodeid;
463 AddTail(&csd->rtglist, &node1->node);
464
465 DB2(bug("Added %dx%d %08x %d\n", node1->width, node1->height, node1->modeid, p96mode));
466 }
467 HIDD_Gfx_ReleaseModeIDs(o, midp);
468 csd->superforward = FALSE;
469
470 }
471
472 FreeVec(restags);
473 FreeVec(reslist);
474 FreeVec(pflist);
475 FreeVec(modetags);
476
477 ReturnPtr("UAEGFX::New", OOP_Object *, o);
478 }
479
480 /********** GfxHidd::Dispose() ******************************/
481 OOP_Object *UAEGFXCl__Hidd_Gfx__NewBitMap(OOP_Class *cl, OOP_Object *o, struct pHidd_Gfx_NewBitMap *msg)
482 {
483 struct uaegfx_staticdata *csd = CSD(cl);
484 HIDDT_ModeID modeid;
485 struct pHidd_Gfx_NewBitMap newbitmap;
486 struct TagItem tags[2];
487
488 EnterFunc(bug("UAEGFX::NewBitMap()\n"));
489
490 modeid = (HIDDT_ModeID)GetTagData(aHidd_BitMap_ModeID, vHidd_ModeID_Invalid, msg->attrList);
491 if (modeid != vHidd_ModeID_Invalid) {
492 tags[0].ti_Tag = aHidd_BitMap_ClassPtr;
493 tags[0].ti_Data = (IPTR)CSD(cl)->bmclass;
494 tags[1].ti_Tag = TAG_MORE;
495 tags[1].ti_Data = (IPTR)msg->attrList;
496 newbitmap.mID = msg->mID;
497 newbitmap.attrList = tags;
498 msg = &newbitmap;
499 }
500
501 ReturnPtr("UAEGFX::NewBitMap", OOP_Object *, (OOP_Object *)OOP_DoSuperMethod(cl, o, (OOP_Msg)msg));
502 }
503
504 VOID UAEGFXCl__Root__Get(OOP_Class *cl, OOP_Object *o, struct pRoot_Get *msg)
505 {
506 struct uaegfx_staticdata *csd = CSD(cl);
507 ULONG idx;
508
509 //bug("UAEGFXCl__Root__Get %x\n", msg->attrID);
510
511 if (IS_GFX_ATTR(msg->attrID, idx))
512 {
513 //bug("=%x\n", idx);
514 switch (idx)
515 {
516 case aoHidd_Gfx_HWSpriteTypes:
517 *msg->storage = csd->hardwaresprite ? vHidd_SpriteType_3Plus1 : 0;
518 return;
519 case aoHidd_Gfx_SupportsHWCursor:
520 *msg->storage = csd->hardwaresprite;
521 return;
522 case aoHidd_Gfx_NoFrameBuffer:
523 *msg->storage = TRUE;
524 return;
525 case aoHidd_Gfx_IsWindowed:
526 *msg->storage = FALSE;
527 return;
528 case aoHidd_Gfx_DriverName:
529 *msg->storage = (IPTR)"UAEGFX";
530 return;
531 }
532 }
533 OOP_DoSuperMethod(cl, o, (OOP_Msg)msg);
534 }
535
536 VOID UAEGFXCl__Root__Set(OOP_Class *cl, OOP_Object *obj, struct pRoot_Set *msg)
537 {
538 struct uaegfx_staticdata *csd = CSD(cl);
539 struct TagItem *tag;
540 const struct TagItem *tstate;
541
542 tstate = msg->attrList;
543 while((tag = NextTagItem(&tstate)))
544 {
545 ULONG idx;
546 D(bug("UAEGFXCl__Root__Set %x\n", tag->ti_Tag));
547 if (IS_GFX_ATTR(tag->ti_Tag, idx)) {
548 D(bug("->%d\n", idx));
549 switch(idx)
550 {
551 case aoHidd_Gfx_ActiveCallBack:
552 csd->acb = (void *)tag->ti_Data;
553 break;
554
555 case aoHidd_Gfx_ActiveCallBackData:
556 csd->acbdata = (APTR)tag->ti_Data;
557 break;
558 }
559 }
560 }
561 OOP_DoSuperMethod(cl, obj, (OOP_Msg)msg);
562 }
563 #if 0
564 ULONG UAEGFXCl__Hidd_Gfx__MakeViewPort(OOP_Class *cl, OOP_Object *o, struct pHidd_Gfx_MakeViewPort *msg)
565 {
566 struct uaegfx_staticdata *csd = CSD(cl);
567
568 csd->vpe = NULL;
569 if (!msg)
570 return MVP_OK;
571 bug("makeviewport %p\n", msg->Data->vpe);
572 csd->vpe = msg->Data->vpe;
573 return MVP_OK;
574 }
575
576 void UAEGFXCl__Hidd_Gfx__CleanViewPort(OOP_Class *cl, OOP_Object *o, struct pHidd_Gfx_CleanViewPort *msg)
577 {
578 struct uaegfx_staticdata *csd = CSD(cl);
579
580 csd->vpe = NULL;
581 bug("cleanviewport\n");
582 }
583 #endif
584
585 static void doshow(struct uaegfx_staticdata *csd, OOP_Object *bm, struct ViewPort *vp, BOOL offonly)
586 {
587 struct IntuitionBase *ib = (struct IntuitionBase*)csd->cs_IntuitionBase;
588 struct Library *OOPBase = csd->cs_OOPBase;
589 struct ViewPort *vpi = NULL;
590
591 if (ib->FirstScreen)
592 vpi = &ib->FirstScreen->ViewPort;
593
594 D(bug("doshow b=%p vp=%p vpi=%p acb=%p acbd=%p\n", bm, vp, vpi, csd->acb, csd->acbdata));
595
596 if (bm && vpi == vp) {
597 /* we are topmost screen -> show our display */
598 IPTR tags[] = {aHidd_BitMap_Visible, TRUE, TAG_DONE};
599
600 if (offonly)
601 return;
602
603 OOP_SetAttrs(bm, (struct TagItem *)tags);
604
605 if (csd->acb)
606 csd->acb(csd->acbdata, NULL);
607
608 } else if (bm) {
609 /* we are not topmost -> turn off our display */
610 IPTR tags[] = {aHidd_BitMap_Visible, FALSE, TAG_DONE};
611 OOP_SetAttrs(bm, (struct TagItem *)tags);
612 } else {
613 /* no display */
614 SetDisplay(csd, FALSE);
615 SetSwitch(csd, FALSE);
616 }
617 }
618
619 OOP_Object *UAEGFXCl__Hidd_Gfx__Show(OOP_Class *cl, OOP_Object *c, struct pHidd_Gfx_Show *msg)
620 {
621 struct uaegfx_staticdata *csd = CSD(cl);
622
623 doshow(csd, msg->bitMap, csd->viewport, FALSE);
624 return msg->bitMap;
625 }
626
627 ULONG UAEGFXCl__Hidd_Gfx__PrepareViewPorts(OOP_Class *cl, OOP_Object *o, struct pHidd_Gfx_ShowViewPorts *msg)
628 {
629 struct uaegfx_staticdata *csd = CSD(cl);
630 struct HIDD_ViewPortData *vpd = msg->Data;
631 OOP_Object *bm = NULL;
632 struct ViewPort *vp = NULL;
633
634 if (vpd) {
635 bm = vpd->Bitmap;
636 if (vpd->vpe)
637 vp = vpd->vpe->ViewPort;
638 }
639 csd->viewport = vp;
640 doshow(csd, bm, vp, FALSE);
641
642 bug("PrepareViewPorts viewport=%p\n", csd->viewport);
643 return MCOP_OK;
644 }
645
646 ULONG UAEGFXCl__Hidd_Gfx__ShowViewPorts(OOP_Class *cl, OOP_Object *o, struct pHidd_Gfx_ShowViewPorts *msg)
647 {
648 struct uaegfx_staticdata *csd = CSD(cl);
649 struct HIDD_ViewPortData *vpd = msg->Data;
650 OOP_Object *bm = NULL;
651 struct ViewPort *vp = NULL;
652
653 if (vpd) {
654 bm = vpd->Bitmap;
655 if (vpd->vpe)
656 vp = vpd->vpe->ViewPort;
657 }
658 doshow(csd, bm, vp, FALSE);
659 return TRUE;
660 }
661
662 VOID UAEGFXCl__Hidd_Gfx__CopyBox(OOP_Class *cl, OOP_Object *o, struct pHidd_Gfx_CopyBox *msg)
663 {
664 struct uaegfx_staticdata *csd = CSD(cl);
665 HIDDT_DrawMode mode = GC_DRMD(msg->gc);
666 struct bm_data *sdata = OOP_INST_DATA(OOP_OCLASS(msg->src), msg->src);
667 struct bm_data *ddata = OOP_INST_DATA(OOP_OCLASS(msg->dest), msg->dest);
668 struct RenderInfo risrc, ridst;
669
670 WaitBlitter(csd);
671 if (sdata->rgbformat != ddata->rgbformat || !sdata->invram || !ddata->invram) {
672 OOP_DoSuperMethod(cl, o, (OOP_Msg)msg);
673 return;
674 }
675 makerenderinfo(csd, &risrc, sdata);
676 makerenderinfo(csd, &ridst, ddata);
677 if (!BlitRectNoMaskComplete(csd, &risrc, &ridst,
678 msg->srcX, msg->srcY, msg->destX, msg->destY,
679 msg->width, msg->height, modetable[mode], sdata->rgbformat))
680 OOP_DoSuperMethod(cl, o, (OOP_Msg)msg);
681 }
682
683 BOOL UAEGFXCl__Hidd_Gfx__CopyBoxMasked(OOP_Class *cl, OOP_Object *o, struct pHidd_Gfx_CopyBoxMasked *msg)
684 {
685 struct uaegfx_staticdata *csd = CSD(cl);
686
687 WaitBlitter(csd);
688 return OOP_DoSuperMethod(cl, o, (OOP_Msg)msg);
689 }
690
691 BOOL UAEGFXCl__Hidd_Gfx__SetCursorShape(OOP_Class *cl, OOP_Object *shape, struct pHidd_Gfx_SetCursorShape *msg)
692 {
693 struct uaegfx_staticdata *csd = CSD(cl);
694 OOP_Object *cm = NULL;
695 IPTR width, height;
696 WORD x, y, hiressprite, i;
697 UWORD *p;
698 ULONG flags;
699 struct Library *OOPBase = csd->cs_OOPBase;
700
701 OOP_GetAttr(msg->shape, aHidd_BitMap_Width, &width);
702 OOP_GetAttr(msg->shape, aHidd_BitMap_Height, &height);
703 OOP_GetAttr(msg->shape, aHidd_BitMap_ColorMap, (IPTR*)&cm);
704 if (cm) {
705 for (i = 0; i < 3; i++) {
706 HIDDT_Color c;
707 HIDD_CM_GetColor(cm, i + 1, &c);
708 SetSpriteColor(csd, i, c.red, c.green, c.blue);
709 }
710 }
711 Forbid();
712 pb(csd->boardinfo + PSSO_BoardInfo_MouseXOffset, msg->xoffset);
713 pb(csd->boardinfo + PSSO_BoardInfo_MouseYOffset, msg->yoffset);
714 p = (UWORD*)gp(csd->boardinfo + PSSO_BoardInfo_MouseImage);
715 if (p == NULL || width != csd->sprite_width || height != csd->sprite_height) {
716 FreeVec(p);
717 p = AllocVec(4 + 4 + ((width + 15) & ~15) / 8 * height * 2, MEMF_CLEAR | MEMF_PUBLIC);
718 pp(csd->boardinfo + PSSO_BoardInfo_MouseImage, p);
719 if (!p) {
720 Permit();
721 return FALSE;
722 }
723 csd->sprite_width = width;
724 csd->sprite_height = height;
725 }
726
727 flags = gl(csd->boardinfo + PSSO_BoardInfo_Flags);
728 flags &= ~(1 << BIB_HIRESSPRITE);
729 hiressprite = 1;
730 if (width > 16) {
731 flags |= 1 << BIB_HIRESSPRITE;
732 hiressprite = 2;
733 }
734 pl(csd->boardinfo + PSSO_BoardInfo_Flags, flags);
735
736 pb(csd->boardinfo + PSSO_BoardInfo_MouseWidth, width / hiressprite);
737 pb(csd->boardinfo + PSSO_BoardInfo_MouseHeight, height);
738
739 p += 2 * hiressprite;
740 for(y = 0; y < height; y++) {
741 UWORD pix1 = 0, pix2 = 0, xcnt = 0;
742 for(x = 0; x < width; x++) {
743 UBYTE c = HIDD_BM_GetPixel(msg->shape, x, y);
744 pix1 <<= 1;
745 pix2 <<= 1;
746 pix1 |= (c & 1) ? 1 : 0;
747 pix2 |= (c & 2) ? 1 : 0;
748 xcnt++;
749 if (xcnt == 15) {
750 xcnt = 0;
751 p[x / 16] = pix1;
752 p[width / 16 + x / 16] = pix2;
753 }
754 }
755 p += (width / 16) * 2;
756 }
757 Permit();
758 SetSpriteImage(csd);
759 return TRUE;
760 }
761
762 BOOL UAEGFXCl__Hidd_Gfx__SetCursorPos(OOP_Class *cl, OOP_Object *o, struct pHidd_Gfx_SetCursorPos *msg)
763 {
764 struct uaegfx_staticdata *csd = CSD(cl);
765 pw(csd->boardinfo + PSSO_BoardInfo_MouseX, msg->x);
766 pw(csd->boardinfo + PSSO_BoardInfo_MouseY, msg->y);
767 SetSpritePosition(csd);
768 return TRUE;
769 }
770 VOID UAEGFXCl__Hidd_Gfx__SetCursorVisible(OOP_Class *cl, OOP_Object *o, struct pHidd_Gfx_SetCursorVisible *msg)
771 {
772 struct uaegfx_staticdata *csd = CSD(cl);
773 SetSprite(csd, msg->visible);
774 }
775
776 BOOL UAEGFXCl__Hidd_Gfx__CheckMode(OOP_Class *cl, OOP_Object *o, struct pHidd_Gfx_CheckMode *msg)
777 {
778 struct uaegfx_staticdata *csd = CSD(cl);
779 struct Library *OOPBase = csd->cs_OOPBase;
780 IPTR width, height, bpp;
781
782 OOP_GetAttr(msg->sync, aHidd_Sync_HDisp, &width);
783 OOP_GetAttr(msg->sync, aHidd_Sync_VDisp, &height);
784 OOP_GetAttr(msg->pixFmt, aHidd_PixFmt_BytesPerPixel, &bpp);
785 if (width > csd->maxwidth[bpp])
786 return FALSE;
787 if (height > csd->maxheight[bpp])
788 return FALSE;
789 return width * height * bpp < csd->vram_size;
790 }
791
792
793 static void freeattrbases(LIBBASETYPEPTR LIBBASE, struct uaegfx_staticdata *csd)
794 {
795 struct Library *OOPBase = GM_OOPBASE_FIELD(LIBBASE);
796
797 OOP_ReleaseAttrBase(IID_Hidd_BitMap);
798 OOP_ReleaseAttrBase(IID_Hidd_UAEGFXBitMap);
799 OOP_ReleaseAttrBase(IID_Hidd_GC);
800 OOP_ReleaseAttrBase(IID_Hidd_Sync);
801 OOP_ReleaseAttrBase(IID_Hidd_Gfx);
802 OOP_ReleaseAttrBase(IID_Hidd_PixFmt);
803 OOP_ReleaseAttrBase(IID_Hidd_ColorMap);
804 }
805
806 AROS_UFH4(APTR, rtg_vblank,
807 AROS_UFHA(ULONG, dummy, A0),
808 AROS_UFHA(APTR, boardinfo, A1),
809 AROS_UFHA(ULONG, dummy2, A5),
810 AROS_UFHA(struct ExecBase *, SysBase, A6))
811 {
812 AROS_USERFUNC_INIT
813
814 return 0;
815
816 AROS_USERFUNC_EXIT
817
818 }
819
820 struct P96RTGmode
821 {
822 UWORD w, h, id;
823 ULONG clock;
824 UWORD htotal, vtotal;
825 UWORD hborder, vborder;
826 UWORD hpos, vpos;
827 UWORD hsync, vsync;
828 UBYTE flags;
829 };
830
831 static const struct P96RTGmode rtgmodes[] =
832 {
833 { 320, 240, 1, 16000000, 416, 260, 0, 0, 40, 5, 16, 1, GMF_HPOLARITY | GMF_VPOLARITY | GMF_DOUBLESCAN },
834 { 640, 480, 3, 31000000, 832, 520, 0, 0, 48, 9, 80, 3, GMF_HPOLARITY | GMF_VPOLARITY },
835 { 800, 600, 4, 40100000, 1056, 620, 0, 0, 56, 1, 112, 2, 0 },
836 { 1024, 768, 5, 65000000, 1344, 806, 0, 0, 88, 3, 88, 6, GMF_HPOLARITY | GMF_VPOLARITY },
837 { 0 }
838 };
839 /* real RTG only */
840 static BOOL PopulateModeInfo(struct uaegfx_staticdata *csd, struct LibResolution *res, const struct P96RTGmode *mode)
841 {
842 UWORD rgbformat;
843 BOOL ok = FALSE;
844
845 for (rgbformat = 0; rgbformat < RGBFB_MaxFormats; rgbformat++) {
846 ULONG clockindex;
847 UBYTE depth, index;
848 struct ModeInfo *mi;
849 UWORD maxhval, maxvval, maxhres, maxvres;
850
851 if (!((1 << rgbformat) & RGBFB_SUPPORTMASK))
852 continue;
853 if (!((1 << rgbformat) & gw(csd->boardinfo + PSSO_BoardInfo_RGBFormats)))
854 continue;
855 depth = getrtgdepth(1 << rgbformat);
856 index = (depth + 7) / 8;
857 if (res->Modes[index])
858 continue;
859
860 maxhval = gw(csd->boardinfo + PSSO_BoardInfo_MaxHorValue + index * 2);
861 maxvval = gw(csd->boardinfo + PSSO_BoardInfo_MaxVerValue + index * 2);
862 maxhres = gw(csd->boardinfo + PSSO_BoardInfo_MaxHorResolution + index * 2);
863 maxvres = gw(csd->boardinfo + PSSO_BoardInfo_MaxVerResolution + index * 2);
864
865 if (mode->htotal > maxhval || mode->vtotal > maxvval ||
866 mode->w > maxhres || mode->h > maxvres)
867 continue;
868
869 mi = AllocMem(sizeof(struct ModeInfo), MEMF_CLEAR | MEMF_PUBLIC);
870 if (!mi)
871 continue;
872 mi->OpenCount = 1;
873 mi->Active = TRUE;
874 mi->Width = mode->w;
875 mi->Height = mode->h;
876 mi->Depth = depth;
877 mi->HorTotal = mode->htotal;
878 mi->VerTotal = mode->vtotal;
879 mi->HorBlankSize = mode->hborder;
880 mi->VerBlankSize = mode->vborder;
881 mi->HorSyncStart = mode->hpos;
882 mi->VerSyncStart = mode->vpos;
883 mi->HorSyncSize = mode->hsync;
884 mi->VerSyncSize = mode->vsync;
885 mi->Flags = mode->flags;
886 clockindex = ResolvePixelClock(csd, mi, mode->clock, rgbformat);
887 mi->PixelClock = GetPixelClock(csd, mi, clockindex, rgbformat);
888 DRTG(bug("%d,%p: %dx%dx%d ci=%d clk=%d (%d/%d)\n",
889 index, mi, mi->Width, mi->Height, mi->Depth,
890 clockindex, mi->PixelClock, mi->Numerator, mi->Denominator));
891 res->Modes[index] = mi;
892 ok = TRUE;
893 }
894 return ok;
895 }
896 static void PopulateResolutionList(struct uaegfx_staticdata *csd)
897 {
898 struct LibResolution *node;
899 UWORD cnt;
900
901 NEWLIST((csd->boardinfo + PSSO_BoardInfo_ResolutionsList));
902 for (cnt = 0; rtgmodes[cnt].clock; cnt++) {
903 const struct P96RTGmode *mode = &rtgmodes[cnt];
904 node = AllocMem(sizeof(struct LibResolution), MEMF_CLEAR | MEMF_PUBLIC);
905 if (!node)
906 break;
907 node->Width = mode->w;
908 node->Height = mode->h;
909 node->DisplayID = 0x50001000 | (mode->id << 16);
910 node->BoardInfo = csd->boardinfo;
911 if (PopulateModeInfo(csd, node, mode))
912 AddTail((struct List*)(csd->boardinfo + PSSO_BoardInfo_ResolutionsList), (struct Node*)node);
913 else
914 FreeMem(node, sizeof(struct LibResolution));
915 }
916 }
917
918 static int openall(struct uaegfx_staticdata *csd)
919 {
920 if ((csd->cs_UtilityBase = TaggedOpenLibrary(TAGGEDOPEN_UTILITY))) {
921 if ((csd->cs_IntuitionBase = TaggedOpenLibrary(TAGGEDOPEN_INTUITION))) {
922 if ((csd->cs_OOPBase = OpenLibrary("oop.library", 0))) {
923 return TRUE;
924 }
925 }
926 }
927 return FALSE;
928 }
929 static void freeall(struct uaegfx_staticdata *csd)
930 {
931 CloseLibrary(csd->cs_IntuitionBase);
932 CloseLibrary(csd->cs_UtilityBase);
933 CloseLibrary(csd->cs_OOPBase);
934 FreeMem(csd->vmem, sizeof(struct MemHeader));
935 csd->vmem = NULL;
936 FreeVec(csd->boardinfo);
937 csd->boardinfo = NULL;
938 }
939
940 static void P96DebugInfo(struct uaegfx_staticdata *csd)
941 {
942 UBYTE i;
943 DRTG(bug("Name:'%s'\n",
944 gl(csd->boardinfo + PSSO_BoardInfo_BoardName)));
945 DRTG(bug("Reg:%08x IO:%08x\n",
946 gl(csd->boardinfo + PSSO_BoardInfo_RegisterBase),
947 gl(csd->boardinfo + PSSO_BoardInfo_MemoryIOBase)));
948 DRTG(bug("BoardType:%d GCType:%d PCType:%d BPC:%d Flags:%08x\n",
949 gl(csd->boardinfo + PSSO_BoardInfo_BoardType),
950 gl(csd->boardinfo + PSSO_BoardInfo_GraphicsControllerType),
951 gl(csd->boardinfo + PSSO_BoardInfo_PaletteChipType),
952 gw(csd->boardinfo + PSSO_BoardInfo_BitsPerCannon),
953 gl(csd->boardinfo + PSSO_BoardInfo_Flags)));
954 for (i = 0; i < MAXMODES; i++) {
955 DRTG(bug("%d: HV:%4d VV: %4d HR:%4d VR:%4d C:%d\n", i,
956 gw(csd->boardinfo + PSSO_BoardInfo_MaxHorValue + i * 2),
957 gw(csd->boardinfo + PSSO_BoardInfo_MaxVerValue + i * 2),
958 gw(csd->boardinfo + PSSO_BoardInfo_MaxHorResolution + i * 2),
959 gw(csd->boardinfo + PSSO_BoardInfo_MaxVerResolution + i * 2),
960 gl(csd->boardinfo + PSSO_BoardInfo_PixelClockCount + i * 4)));
961 }
962 }
963
964 static BOOL P96Init(struct uaegfx_staticdata *csd, struct Library *lib)
965 {
966 DRTG(bug("P96GFX: attempting to init '%s'\n", lib->lib_Node.ln_Name));
967 pl(csd->boardinfo + PSSO_BoardInfo_CardBase, (ULONG)lib);
968 csd->CardBase = lib;
969 InitRTG(csd->boardinfo);
970 if (FindCard(csd)) {
971 DRTG(bug("P96GFX: FindCard succeeded\n"));
972 if (InitCard(csd)) {
973 DRTG(bug("P96GFX: InitCard succeeded\n"));
974 SetInterrupt(csd, FALSE);
975 /* Without this card may not be in linear memory map mode. */
976 SetMemoryMode(csd, RGBFB_CLUT);
977 P96DebugInfo(csd);
978 return TRUE;
979 }
980 }
981 pl(csd->boardinfo + PSSO_BoardInfo_CardBase, 0);
982 csd->CardBase = NULL;
983 return FALSE;
984 }
985
986
987 BOOL Init_UAEGFXClass(LIBBASETYPEPTR LIBBASE)
988 {
989 struct uaegfx_staticdata *csd = &LIBBASE->csd;
990 struct MemChunk *mc;
991 struct Library *OOPBase;
992 UBYTE i;
993 struct Interrupt *intr;
994 struct Node *node;
995
996 if (!(SysBase->AttnFlags & AFF_68020))
997 return FALSE;
998
999 D(bug("Init_UAEGFXClass\n"));
1000 if (!openall(csd)) {
1001 freeall(csd);
1002 return FALSE;
1003 }
1004
1005 OOPBase = csd->cs_OOPBase;
1006
1007 csd->boardinfo = AllocVec(PSSO_BoardInfo_SizeOf + PSSO_BitMapExtra_Last + sizeof(struct ModeInfo), MEMF_CLEAR | MEMF_PUBLIC);
1008 if (!csd->boardinfo) {
1009 freeall(csd);
1010 return FALSE;
1011 }
1012 NEWLIST((struct List*)(csd->boardinfo + PSSO_BoardInfo_ResolutionsList));
1013 NEWLIST((struct List*)(csd->boardinfo + PSSO_BoardInfo_BitMapList));
1014 NEWLIST((struct List*)(csd->boardinfo + PSSO_BoardInfo_MemList));
1015 NEWLIST((struct List*)(csd->boardinfo + PSSO_BoardInfo_WaitQ));
1016 csd->bitmapextra = csd->boardinfo + PSSO_BoardInfo_SizeOf;
1017 csd->fakemodeinfo = (struct ModeInfo*)(csd->boardinfo + PSSO_BoardInfo_SizeOf + PSSO_BitMapExtra_Last);
1018 pl(csd->boardinfo + PSSO_BoardInfo_BitMapExtra, (ULONG)csd->bitmapextra);
1019 pl(csd->boardinfo + PSSO_BoardInfo_ExecBase, (ULONG)SysBase);
1020 pl(csd->boardinfo + PSSO_BoardInfo_UtilBase, (ULONG)csd->cs_UtilityBase);
1021 InitSemaphore((struct SignalSemaphore*)(csd->boardinfo + PSSO_BoardInfo_BoardLock));
1022 intr = (struct Interrupt*)(csd->boardinfo + PSSO_BoardInfo_HardInterrupt);
1023 intr->is_Code = (APTR)rtg_vblank;
1024 intr->is_Data = csd->boardinfo;
1025 intr->is_Node.ln_Name = "RTG VBlank";
1026 intr->is_Node.ln_Pri = 0;
1027 intr->is_Node.ln_Type = NT_INTERRUPT;
1028 intr = (struct Interrupt*)(csd->boardinfo + PSSO_BoardInfo_SoftInterrupt);
1029 intr->is_Code = (APTR)rtg_vblank;
1030 intr->is_Data = csd->boardinfo;
1031 intr->is_Node.ln_Name = "RTG VBlank";
1032 intr->is_Node.ln_Pri = 0;
1033 intr->is_Node.ln_Type = NT_INTERRUPT;
1034
1035 Forbid();
1036 ForeachNode(&SysBase->LibList.lh_Head, node) {
1037 struct Library *lib = (struct Library*)node;
1038 char *name = node->ln_Name;
1039 int len = strlen(name);
1040 if (len > 5 && !stricmp(name + len - 5, ".card")) {
1041 BOOL ret;
1042 Permit();
1043 ret = P96Init(csd, lib);
1044 Forbid();
1045 if (ret)
1046 break;
1047 DRTG(bug("P96GFX: init failed\n"));
1048 }
1049 }
1050 Permit();
1051
1052 if (!csd->CardBase) {
1053 csd->uaeromvector = (APTR)(0xf00000 + 0xff60);
1054 if ((gl(csd->uaeromvector) & 0xff00ffff) != 0xa0004e75) {
1055 D(bug("UAE boot ROM entry point not found. UAEGFX not enabled.\n"));
1056 freeall(csd);
1057 return FALSE;
1058 }
1059 if (!FindCard(csd)) {
1060 D(bug("UAEGFX: FindCard() returned false\n"));
1061 freeall(csd);
1062 return FALSE;
1063 }
1064 D(bug("UAEGFX: FindCard done\n"));
1065 InitCard(csd);
1066 csd->hardwaresprite = (gl(csd->boardinfo + PSSO_BoardInfo_Flags) & (1 << BIB_HARDWARESPRITE)) && SetSprite(csd, FALSE);
1067 } else {
1068 PopulateResolutionList(csd);
1069 csd->hardwaresprite = gl(csd->boardinfo + PSSO_BoardInfo_Flags) & (1 << BIB_HARDWARESPRITE);
1070 }
1071
1072 if (IsListEmpty((struct List*)(csd->boardinfo + PSSO_BoardInfo_ResolutionsList))) {
1073 D(bug("Resolutionlist is empty, init failed.\n"));
1074 freeall(csd);
1075 return FALSE;
1076 }
1077 for (i = 0; i < MAXMODES; i++) {
1078 csd->maxwidth[i] = gw(csd->boardinfo + PSSO_BoardInfo_MaxHorResolution + i * 2);
1079 csd->maxheight[i] = gw(csd->boardinfo + PSSO_BoardInfo_MaxVerResolution + i * 2);
1080 }
1081
1082 D(bug("InitCard done\n"));
1083
1084 DRTG(bug("hardware sprite: %d\n", csd->hardwaresprite));
1085
1086 csd->vram_start = (UBYTE*)gl(csd->boardinfo + PSSO_BoardInfo_MemoryBase);
1087 csd->vram_size = gl(csd->boardinfo + PSSO_BoardInfo_MemorySize);
1088
1089 DRTG(bug("P96RTG VRAM found at %08x size %08x\n", csd->vram_start, csd->vram_size));
1090 mc = (struct MemChunk*)csd->vram_start;
1091 csd->vmem = AllocVec(sizeof(struct MemHeader), MEMF_CLEAR | MEMF_PUBLIC);
1092 csd->vmem->mh_Node.ln_Type = NT_MEMORY;
1093 csd->vmem->mh_First = mc;
1094 csd->vmem->mh_Lower = (APTR)mc;
1095 csd->vmem->mh_Upper = (APTR)((ULONG)mc + csd->vram_size);
1096 csd->vmem->mh_Free = csd->vram_size;
1097 mc->mc_Next = NULL;
1098 mc->mc_Bytes = csd->vmem->mh_Free;
1099
1100 __IHidd_BitMap = OOP_ObtainAttrBase(IID_Hidd_BitMap);
1101 __IHidd_UAEGFXBitmap= OOP_ObtainAttrBase(IID_Hidd_UAEGFXBitMap);
1102 __IHidd_GC = OOP_ObtainAttrBase(IID_Hidd_GC);
1103 __IHidd_Sync = OOP_ObtainAttrBase(IID_Hidd_Sync);
1104 __IHidd_Gfx = OOP_ObtainAttrBase(IID_Hidd_Gfx);
1105 __IHidd_PixFmt = OOP_ObtainAttrBase(IID_Hidd_PixFmt);
1106 __IHidd_ColorMap = OOP_ObtainAttrBase(IID_Hidd_ColorMap);
1107
1108 HiddBitMapBase = OOP_GetMethodID(IID_Hidd_BitMap, 0);
1109 HiddColorMapBase = OOP_GetMethodID(IID_Hidd_ColorMap, 0);
1110 HiddGfxBase = OOP_GetMethodID(IID_Hidd_Gfx, 0);
1111
1112 if (!__IHidd_BitMap || !__IHidd_UAEGFXBitmap || !__IHidd_GC ||
1113 !__IHidd_Sync || !__IHidd_Gfx || !__IHidd_PixFmt || !__IHidd_ColorMap)
1114 {
1115 D(bug("Init_UAEGFXClass fail\n"));
1116 freeattrbases(LIBBASE, csd);
1117 freeall(csd);
1118 return FALSE;
1119 }
1120
1121 DRTG(bug("P96RTG done\n"));
1122 return TRUE;
1123 }
1124
1125 static int Expunge_UAEGFXClass(LIBBASETYPEPTR LIBBASE)
1126 {
1127 struct uaegfx_staticdata *csd = &LIBBASE->csd;
1128 D(bug("Expunge_UAEGFXClass\n"));
1129 freeattrbases(LIBBASE, csd);
1130 freeall(csd);
1131 return TRUE;
1132 }
1133
1134 ADD2EXPUNGELIB(Expunge_UAEGFXClass, 1)
Mirror of AROS' svn.