arch/m68k-amiga/hidd/uaegfx/uaertg.c

   1 /*
   2     Copyright © 1995-2014, The AROS Development Team. All rights reserved.
   3     $Id$
   4 */
   5
   6 #include <aros/debug.h>
   7 #include <proto/oop.h>
   8 #include <hidd/hidd.h>
   9 #include <hidd/graphics.h>
  10 #include <aros/libcall.h>
  11 #include <aros/symbolsets.h>
  12 #include <oop/oop.h>
  13
  14 #include "uaegfx.h"
  15 #include "uaegfxbitmap.h"
  16 #include "uaertg.h"
  17 #include "p96call.h"
  18
  19 static APTR gptr(struct uaegfx_staticdata *csd, WORD offset)
  20 {
  21     APTR code = (APTR)((ULONG*)(((UBYTE*)(csd->boardinfo)) + offset))[0];
  22     D(bug("->RTG off=%d code=%p\n", (offset - (PSSO_BoardInfo_AllocCardMem)) / 4, code));
  23 #if 0
  24     UBYTE *board = gl(csd->boardinfo + PSSO_BoardInfo_MemoryBase);
  25     bug("%08x: %08x %08x %08x %08x\n",
  26         board,
  27         gl(board + 0),
  28         gl(board + 4),
  29         gl(board + 8),
  30         gl(board + 12));
  31 #endif
  32     pw (csd->boardinfo + PSSO_BoardInfo_AROSFlag, 1);
  33     return code;
  34 }
  35
  36 static AROS_UFH1(ULONG, RTGCall_Default,
  37     AROS_UFHA(APTR, boardinfo, A0))
  38 {
  39     AROS_USERFUNC_INIT
  40
  41     pw (boardinfo + PSSO_BoardInfo_AROSFlag, 0);
  42     return 0;
  43
  44     AROS_USERFUNC_EXIT
  45 }
  46
  47 /* Set fallback functions */
  48 void InitRTG(APTR boardinfo)
  49 {
  50     UWORD i;
  51
  52     for (i = PSSO_BoardInfo_AllocCardMem; i <= PSSO_BoardInfo_DeleteFeature; i += 4)
  53         pl(boardinfo + i, (ULONG)RTGCall_Default);
  54 }
  55
  56 BOOL FindCard(struct uaegfx_staticdata *csd)
  57 {
  58     if (csd->CardBase)
  59         return AROS_LVO_CALL1(BOOL,
  60             AROS_LCA(APTR, csd->boardinfo, A0),
  61             struct Library*, csd->CardBase, 5, );
  62     else
  63         return P96_LC1(BOOL, csd->uaeromvector, 16,
  64             AROS_LCA(APTR, csd->boardinfo, A0));
  65 }
  66 BOOL InitCard(struct uaegfx_staticdata *csd)
  67 {
  68     if (csd->CardBase)
  69         return AROS_LVO_CALL2(BOOL,
  70             AROS_LCA(APTR, csd->boardinfo, A0),
  71             AROS_LCA(APTR, NULL, A1),
  72             struct Library*, csd->CardBase, 6, );
  73    else
  74         return P96_LC2(BOOL, csd->uaeromvector, 29,
  75             AROS_LCA(APTR, csd->boardinfo, A0),       // For current WinUAEs
  76             AROS_LCA(APTR, csd->boardinfo, A2));      // For older E-UAEs
  77 }
  78
  79 void WaitBlitter(struct uaegfx_staticdata *csd)
  80 {
  81     if (csd->CardBase)
  82         AROS_CALL1NR(void, gptr(csd, PSSO_BoardInfo_WaitBlitter),
  83             AROS_LCA(APTR, csd->boardinfo, A0),
  84             struct Library*, csd->CardBase);
  85 }
  86
  87 void SetInterrupt(struct uaegfx_staticdata *csd, ULONG state)
  88 {
  89     if (csd->CardBase)
  90         AROS_CALL2(ULONG, gptr(csd, PSSO_BoardInfo_SetInterrupt),
  91             AROS_LCA(APTR, csd->boardinfo, A0),
  92             AROS_LCA(ULONG, state, D0),
  93             struct Library*, csd->CardBase);
  94 }
  95
  96 ULONG GetPixelClock(struct uaegfx_staticdata *csd, struct ModeInfo *mi, ULONG index, ULONG rgbformat)
  97 {
  98     if (csd->CardBase)
  99         return AROS_CALL4(ULONG, gptr(csd, PSSO_BoardInfo_GetPixelClock),
 100             AROS_LCA(APTR, csd->boardinfo, A0),
 101             AROS_LCA(APTR, mi, A1),
 102             AROS_LCA(ULONG, index, D0),
 103             AROS_LCA(ULONG, rgbformat, D7),
 104             struct Library*, csd->CardBase);
 105     else
 106         return -2;
 107 }
 108
 109 void SetMemoryMode(struct uaegfx_staticdata *csd, ULONG rgbformat)
 110 {
 111     if (csd->CardBase)
 112         AROS_CALL2(ULONG, gptr(csd, PSSO_BoardInfo_SetMemoryMode),
 113             AROS_LCA(APTR, csd->boardinfo, A0),
 114             AROS_LCA(ULONG, rgbformat, D7),
 115             struct Library*, csd->CardBase);
 116 }
 117
 118 ULONG ResolvePixelClock(struct uaegfx_staticdata *csd, struct ModeInfo *mi, ULONG pixelclock, ULONG rgbformat)
 119 {
 120     if (csd->CardBase)
 121         return AROS_CALL4(ULONG, gptr(csd, PSSO_BoardInfo_ResolvePixelClock),
 122             AROS_LCA(APTR, csd->boardinfo, A0),
 123             AROS_LCA(APTR, mi, A1),
 124             AROS_LCA(ULONG, pixelclock, D0),
 125             AROS_LCA(ULONG, rgbformat, D7),
 126             struct Library*, csd->CardBase);
 127     else
 128         return -2;
 129 }
 130 ULONG SetClock(struct uaegfx_staticdata *csd)
 131 {
 132     if (csd->CardBase)
 133         return AROS_CALL1(ULONG, gptr(csd, PSSO_BoardInfo_SetClock),
 134             AROS_LCA(APTR, csd->boardinfo, A0),
 135             struct Library*, csd->CardBase);
 136     else
 137         return -2;
 138 }
 139 BOOL SetDisplay(struct uaegfx_staticdata *csd, BOOL state)
 140 {
 141     if (csd->CardBase)
 142         return AROS_CALL2(BOOL, gptr(csd, PSSO_BoardInfo_SetDisplay),
 143             AROS_LCA(APTR, csd->boardinfo, A0),
 144             AROS_LCA(BOOL, state, D0),
 145             struct Library*, csd->CardBase);
 146     else
 147         return P96_LC2(BOOL, csd->uaeromvector, 26,
 148             AROS_LCA(APTR, csd->boardinfo, A0),
 149             AROS_LCA(BOOL, state, D0));
 150 }
 151 BOOL SetSwitch(struct uaegfx_staticdata *csd, BOOL state)
 152 {
 153     if (csd->CardBase)
 154         return AROS_CALL2(BOOL, gptr(csd, PSSO_BoardInfo_SetSwitch),
 155             AROS_LCA(APTR, csd->boardinfo, A0),
 156             AROS_LCA(BOOL, state, D0),
 157             struct Library*, csd->CardBase);
 158     else
 159         return P96_LC2(BOOL, csd->uaeromvector, 18,
 160             AROS_LCA(APTR, csd->boardinfo, A0),
 161             AROS_LCA(BOOL, state, D0));
 162 }
 163 void SetColorArray(struct uaegfx_staticdata *csd, UWORD start, UWORD count)
 164 {
 165     if (csd->CardBase)
 166         AROS_CALL3(BOOL, gptr(csd, PSSO_BoardInfo_SetColorArray),
 167             AROS_LCA(APTR, csd->boardinfo, A0),
 168             AROS_LCA(WORD, start, D0),
 169             AROS_LCA(WORD, count, D1),
 170             struct Library*, csd->CardBase);
 171     else
 172         P96_LC3(BOOL, csd->uaeromvector, 19,
 173             AROS_LCA(APTR, csd->boardinfo, A0),
 174             AROS_LCA(WORD, start, D0),
 175             AROS_LCA(WORD, count, D1));
 176 }
 177 void SetDAC(struct uaegfx_staticdata *csd)
 178 {
 179     if (csd->CardBase)
 180         AROS_CALL2(BOOL, gptr(csd, PSSO_BoardInfo_SetDAC),
 181             AROS_LCA(APTR, csd->boardinfo, A0),
 182             AROS_LCA(ULONG, csd->rgbformat, D7),
 183             struct Library*, csd->CardBase);
 184     else
 185         P96_LC2(BOOL, csd->uaeromvector, 20,
 186             AROS_LCA(APTR, csd->boardinfo, A0),
 187             AROS_LCA(ULONG, csd->rgbformat, D7));
 188 }
 189 void SetGC(struct uaegfx_staticdata *csd, struct ModeInfo *mi, BOOL border)
 190 {
 191     if (csd->CardBase)
 192         AROS_CALL3(BOOL, gptr(csd, PSSO_BoardInfo_SetGC),
 193             AROS_LCA(APTR, csd->boardinfo, A0),
 194             AROS_LCA(APTR, mi, A1),
 195             AROS_LCA(BOOL, border, D0),
 196             struct Library*, csd->CardBase);
 197     else
 198         P96_LC3(BOOL, csd->uaeromvector, 21,
 199             AROS_LCA(APTR, csd->boardinfo, A0),
 200             AROS_LCA(APTR, mi, A1),
 201             AROS_LCA(BOOL, border, D0));
 202 }
 203 void SetPanning(struct uaegfx_staticdata *csd, UBYTE *video, UWORD width, WORD x, WORD y)
 204 {
 205     if (csd->CardBase)
 206         AROS_CALL6(BOOL, gptr(csd, PSSO_BoardInfo_SetPanning),
 207             AROS_LCA(APTR, csd->boardinfo, A0),
 208             AROS_LCA(APTR, video, A1),
 209             AROS_LCA(UWORD, width, D0),
 210             AROS_LCA(WORD, x, D1),
 211             AROS_LCA(WORD, y, D2),
 212             AROS_LCA(ULONG, csd->rgbformat, D7),
 213             struct Library*, csd->CardBase);
 214     else
 215         P96_LC6(BOOL, csd->uaeromvector, 22,
 216             AROS_LCA(APTR, csd->boardinfo, A0),
 217             AROS_LCA(APTR, video, A1),
 218             AROS_LCA(UWORD, width, D0),
 219             AROS_LCA(WORD, x, D1),
 220             AROS_LCA(WORD, y, D2),
 221             AROS_LCA(ULONG, csd->rgbformat, D7));
 222 }
 223 BOOL FillRect(struct uaegfx_staticdata *csd, struct RenderInfo *ri, WORD x, WORD y, WORD w, WORD h, ULONG pen, UBYTE mask, ULONG rgbformat)
 224 {
 225     if (csd->CardBase) {
 226         AROS_CALL9(BOOL, gptr(csd, PSSO_BoardInfo_FillRect),
 227             AROS_LCA(APTR, csd->boardinfo, A0),
 228             AROS_LCA(APTR, ri, A1),
 229             AROS_LCA(WORD, x, D0),
 230             AROS_LCA(WORD, y, D1),
 231             AROS_LCA(WORD, w, D2),
 232             AROS_LCA(WORD, h, D3),
 233             AROS_LCA(ULONG, pen, D4),
 234             AROS_LCA(UBYTE, mask, D5),
 235             AROS_LCA(ULONG, rgbformat, D7),
 236             struct Library*, csd->CardBase);
 237         return gw (csd->boardinfo + PSSO_BoardInfo_AROSFlag);
 238     } else
 239         return P96_LC9(BOOL, csd->uaeromvector, 17,
 240             AROS_LCA(APTR, csd->boardinfo, A0),
 241             AROS_LCA(APTR, ri, A1),
 242             AROS_LCA(WORD, x, D0),
 243             AROS_LCA(WORD, y, D1),
 244             AROS_LCA(WORD, w, D2),
 245             AROS_LCA(WORD, h, D3),
 246             AROS_LCA(ULONG, pen, D4),
 247             AROS_LCA(UBYTE, mask, D5),
 248             AROS_LCA(ULONG, rgbformat, D7));
 249 }
 250 BOOL InvertRect(struct uaegfx_staticdata *csd, struct RenderInfo *ri, WORD x, WORD y, WORD w, WORD h, UBYTE mask, ULONG rgbformat)
 251 {
 252     if (csd->CardBase) {
 253         AROS_CALL8(BOOL, gptr(csd, PSSO_BoardInfo_InvertRect),
 254             AROS_LCA(APTR, csd->boardinfo, A0),
 255             AROS_LCA(APTR, ri, A1),
 256             AROS_LCA(WORD, x, D0),
 257             AROS_LCA(WORD, y, D1),
 258             AROS_LCA(WORD, w, D2),
 259             AROS_LCA(WORD, h, D3),
 260             AROS_LCA(UBYTE, mask, D4),
 261             AROS_LCA(ULONG, rgbformat, D7),
 262             struct Library*, csd->CardBase);
 263         return gw (csd->boardinfo + PSSO_BoardInfo_AROSFlag);
 264     } else
 265         return P96_LC8(BOOL, csd->uaeromvector, 31,
 266             AROS_LCA(APTR, csd->boardinfo, A0),
 267             AROS_LCA(APTR, ri, A1),
 268             AROS_LCA(WORD, x, D0),
 269             AROS_LCA(WORD, y, D1),
 270             AROS_LCA(WORD, w, D2),
 271             AROS_LCA(WORD, h, D3),
 272             AROS_LCA(UBYTE, mask, D4),
 273             AROS_LCA(ULONG, rgbformat, D7));
 274 }
 275 BOOL BlitRectNoMaskComplete(struct uaegfx_staticdata *csd, struct RenderInfo *risrc, struct RenderInfo *ridst,
 276     WORD sx, WORD sy, WORD dx, WORD dy, WORD w, WORD h, UBYTE opcode, ULONG rgbformat)
 277 {
 278     if (csd->CardBase) {
 279         AROS_CALL11(BOOL, gptr(csd, PSSO_BoardInfo_BlitRectNoMaskComplete),
 280             AROS_LCA(APTR, csd->boardinfo, A0),
 281             AROS_LCA(APTR, risrc, A1),
 282             AROS_LCA(APTR, ridst, A2),
 283             AROS_LCA(WORD, sx, D0),
 284             AROS_LCA(WORD, sy, D1),
 285             AROS_LCA(WORD, dx, D2),
 286             AROS_LCA(WORD, dy, D3),
 287             AROS_LCA(WORD, w, D4),
 288             AROS_LCA(WORD, h, D5),
 289             AROS_LCA(UBYTE, opcode, D6),
 290             AROS_LCA(ULONG, rgbformat, D7),
 291             struct Library*, csd->CardBase);
 292         return gw (csd->boardinfo + PSSO_BoardInfo_AROSFlag);
 293     } else
 294         return P96_LC11(BOOL, csd->uaeromvector, 28,
 295             AROS_LCA(APTR, csd->boardinfo, A0),
 296             AROS_LCA(APTR, risrc, A1),
 297             AROS_LCA(APTR, ridst, A2),
 298             AROS_LCA(WORD, sx, D0),
 299             AROS_LCA(WORD, sy, D1),
 300             AROS_LCA(WORD, dx, D2),
 301             AROS_LCA(WORD, dy, D3),
 302             AROS_LCA(WORD, w, D4),
 303             AROS_LCA(WORD, h, D5),
 304             AROS_LCA(UBYTE, opcode, D6),
 305             AROS_LCA(ULONG, rgbformat, D7));
 306 };
 307 BOOL BlitPattern(struct uaegfx_staticdata *csd, struct RenderInfo *ri, struct Pattern *pat,
 308     WORD x, WORD y, WORD w, WORD h, UBYTE mask, ULONG rgbformat)
 309 {
 310     if (csd->CardBase) {
 311         AROS_CALL9(BOOL, gptr(csd, PSSO_BoardInfo_BlitPattern),
 312             AROS_LCA(APTR, csd->boardinfo, A0),
 313             AROS_LCA(APTR, ri, A1),
 314             AROS_LCA(APTR, pat, A2),
 315             AROS_LCA(WORD, x, D0),
 316             AROS_LCA(WORD, y, D1),
 317             AROS_LCA(WORD, w, D2),
 318             AROS_LCA(WORD, h, D3),
 319             AROS_LCA(UBYTE, mask, D4),
 320             AROS_LCA(ULONG, rgbformat, D7),
 321             struct Library*, csd->CardBase);
 322         return gw (csd->boardinfo + PSSO_BoardInfo_AROSFlag);
 323     } else
 324         return P96_LC9(BOOL, csd->uaeromvector, 30,
 325             AROS_LCA(APTR, csd->boardinfo, A0),
 326             AROS_LCA(APTR, ri, A1),
 327             AROS_LCA(APTR, pat, A2),
 328             AROS_LCA(WORD, x, D0),
 329             AROS_LCA(WORD, y, D1),
 330             AROS_LCA(WORD, w, D2),
 331             AROS_LCA(WORD, h, D3),
 332             AROS_LCA(UBYTE, mask, D4),
 333             AROS_LCA(ULONG, rgbformat, D7));
 334 }
 335
 336 BOOL BlitTemplate(struct uaegfx_staticdata *csd, struct RenderInfo *ri, struct Template *tmpl,
 337     WORD x, WORD y, WORD w, WORD h, UBYTE mask, ULONG rgbformat)
 338 {
 339     if (csd->CardBase) {
 340         AROS_CALL9(BOOL, gptr(csd, PSSO_BoardInfo_BlitTemplate),
 341             AROS_LCA(APTR, csd->boardinfo, A0),
 342             AROS_LCA(APTR, ri, A1),
 343             AROS_LCA(APTR, tmpl, A2),
 344             AROS_LCA(WORD, x, D0),
 345             AROS_LCA(WORD, y, D1),
 346             AROS_LCA(WORD, w, D2),
 347             AROS_LCA(WORD, h, D3),
 348             AROS_LCA(UBYTE, mask, D4),
 349             AROS_LCA(ULONG, rgbformat, D7),
 350             struct Library*, csd->CardBase);
 351         return gw (csd->boardinfo + PSSO_BoardInfo_AROSFlag);
 352     } else
 353         return P96_LC9(BOOL, csd->uaeromvector, 27,
 354             AROS_LCA(APTR, csd->boardinfo, A0),
 355             AROS_LCA(APTR, ri, A1),
 356             AROS_LCA(APTR, tmpl, A2),
 357             AROS_LCA(WORD, x, D0),
 358             AROS_LCA(WORD, y, D1),
 359             AROS_LCA(WORD, w, D2),
 360             AROS_LCA(WORD, h, D3),
 361             AROS_LCA(UBYTE, mask, D4),
 362             AROS_LCA(ULONG, rgbformat, D7));
 363 }
 364
 365 WORD CalculateBytesPerRow(struct uaegfx_staticdata *csd, WORD width, ULONG rgbformat)
 366 {
 367     if (csd->CardBase)
 368         return AROS_CALL3(BOOL, gptr(csd, PSSO_BoardInfo_CalculateBytesPerRow),
 369             AROS_LCA(APTR, csd->boardinfo, A0),
 370             AROS_LCA(UWORD, width, D0),
 371             AROS_LCA(ULONG, rgbformat, D7),
 372             struct Library*, csd->CardBase);
 373     else
 374         return P96_LC3(BOOL, csd->uaeromvector, 23,
 375             AROS_LCA(APTR, csd->boardinfo, A0),
 376             AROS_LCA(UWORD, width, D0),
 377             AROS_LCA(ULONG, rgbformat, D7));
 378 }
 379
 380 BOOL SetSprite(struct uaegfx_staticdata *csd, BOOL activate)
 381 {
 382     if (csd->CardBase)
 383         return AROS_CALL3(BOOL, gptr(csd, PSSO_BoardInfo_SetSprite),
 384             AROS_LCA(APTR, csd->boardinfo, A0),
 385             AROS_LCA(BOOL, activate, D0),
 386             AROS_LCA(ULONG, csd->rgbformat, D7),
 387             struct Library*, csd->CardBase);
 388     return P96_LC3(BOOL, csd->uaeromvector, 36,
 389         AROS_LCA(APTR, csd->boardinfo, A0),
 390         AROS_LCA(BOOL, activate, D0),
 391         AROS_LCA(ULONG, csd->rgbformat, D7));
 392 }
 393
 394 BOOL SetSpritePosition(struct uaegfx_staticdata *csd)
 395 {
 396     if (csd->CardBase)
 397         return AROS_CALL2(BOOL, gptr(csd, PSSO_BoardInfo_SetSpritePosition),
 398             AROS_LCA(APTR, csd->boardinfo, A0),
 399             AROS_LCA(ULONG, csd->rgbformat, D7),
 400             struct Library*, csd->CardBase);
 401     return P96_LC2(BOOL, csd->uaeromvector, 37,
 402         AROS_LCA(APTR, csd->boardinfo, A0),
 403         AROS_LCA(ULONG, csd->rgbformat, D7));
 404 }
 405
 406 BOOL SetSpriteImage(struct uaegfx_staticdata *csd)
 407 {
 408     if (csd->CardBase)
 409         return AROS_CALL2(BOOL, gptr(csd, PSSO_BoardInfo_SetSpriteImage),
 410             AROS_LCA(APTR, csd->boardinfo, A0),
 411             AROS_LCA(ULONG, csd->rgbformat, D7),
 412             struct Library*, csd->CardBase);
 413     return P96_LC2(BOOL, csd->uaeromvector, 38,
 414         AROS_LCA(APTR, csd->boardinfo, A0),
 415         AROS_LCA(ULONG, csd->rgbformat, D7));
 416 }
 417
 418 BOOL SetSpriteColor(struct uaegfx_staticdata *csd, UBYTE idx, UBYTE r, UBYTE g, UBYTE b)
 419 {
 420     if (csd->CardBase)
 421         return AROS_CALL6(BOOL, gptr(csd, PSSO_BoardInfo_SetSpriteColor),
 422             AROS_LCA(APTR, csd->boardinfo, A0),
 423             AROS_LCA(UBYTE, idx, D0),
 424             AROS_LCA(UBYTE, r, D1),
 425             AROS_LCA(UBYTE, g, D2),
 426             AROS_LCA(UBYTE, b, D3),
 427             AROS_LCA(ULONG, csd->rgbformat, D7),
 428             struct Library*, csd->CardBase);
 429     return P96_LC6(BOOL, csd->uaeromvector, 39,
 430         AROS_LCA(APTR, csd->boardinfo, A0),
 431         AROS_LCA(UBYTE, idx, D0),
 432         AROS_LCA(UBYTE, r, D1),
 433         AROS_LCA(UBYTE, g, D2),
 434         AROS_LCA(UBYTE, b, D3),
 435         AROS_LCA(ULONG, csd->rgbformat, D7));
 436 }
 437
 438 WORD getrtgdepth(ULONG rgbformat)
 439 {
 440     if (rgbformat & RGBFF_CLUT)
 441         return 8;
 442     if (rgbformat & (RGBFF_R5G5B5PC | RGBFF_R5G5B5 | RGBFF_B5G5R5PC))
 443         return 15;
 444     if (rgbformat & (RGBFF_R5G6B5PC | RGBFF_R5G6B5 | RGBFF_B5G6R5PC))
 445         return 16;
 446     if (rgbformat & (RGBFF_R8G8B8 | RGBFF_B8G8R8))
 447         return 24;
 448     if (rgbformat & (RGBFF_A8R8G8B8 | RGBFF_A8B8G8R8 | RGBFF_R8G8B8A8 | RGBFF_B8G8R8A8))
 449         return 32;
 450     return 0;
 451 }
 452
 453 ULONG getrtgformat(struct uaegfx_staticdata *csd, OOP_Object *pixfmt)
 454 {
 455     IPTR depth, redmask, bluemask, endianswitch;
 456
 457     OOP_GetAttr(pixfmt, aHidd_PixFmt_Depth, &depth);
 458     OOP_GetAttr(pixfmt, aHidd_PixFmt_RedMask, &redmask);
 459     OOP_GetAttr(pixfmt, aHidd_PixFmt_BlueMask, &bluemask);
 460     OOP_GetAttr(pixfmt, aHidd_PixFmt_SwapPixelBytes, &endianswitch);
 461
 462     if (depth == 8)
 463         return RGBFB_CLUT;
 464     if (depth == 15) {
 465         if (redmask == 0x00007c00 && !endianswitch)
 466             return RGBFB_R5G5B5;
 467         if (redmask == 0x00007c00 && endianswitch)
 468             return RGBFB_R5G5B5PC;
 469         if (redmask == 0x0000003e && bluemask == 0x0000f800)
 470             return RGBFB_B5G5R5PC;
 471     }
 472     if (depth == 16) {
 473         if (redmask == 0x0000f800 && !endianswitch)
 474             return RGBFB_R5G6B5;
 475         if (redmask == 0x0000f800 && endianswitch)
 476             return RGBFB_R5G6B5PC;
 477         if (redmask == 0x0000001f && bluemask == 0x0000f800)
 478             return RGBFB_B5G6R5PC;
 479     }
 480     if (depth == 32) {
 481         if (redmask == 0x0000ff00)
 482            return RGBFB_B8G8R8A8;
 483         if (redmask == 0xff000000)
 484            return RGBFB_R8G8B8A8;
 485         if (redmask == 0x000000ff)
 486            return RGBFB_A8B8G8R8;
 487         if (redmask == 0x00ff0000)
 488            return RGBFB_A8R8G8B8;
 489     } else if (depth == 24) {
 490         if (redmask == 0x000000ff)
 491            return RGBFB_B8G8R8;
 492         if (redmask == 0x00ff0000)
 493            return RGBFB_R8G8B8;
 494     }
 495     D(bug("getrtgformat RGBFB_NONE!? %d %08x %08x\n", depth, redmask, bluemask));
 496     return RGBFB_NONE;
 497 }
 498
 499 void makerenderinfo(struct uaegfx_staticdata *csd, struct RenderInfo *ri, struct bm_data *bm)
 500 {
 501     ri->Memory = bm->VideoData;
 502     ri->BytesPerRow = bm->bytesperline;
 503     ri->RGBFormat = bm->rgbformat;
 504 }
 505
 506 struct ModeInfo *getrtgmodeinfo(struct uaegfx_staticdata *csd, OOP_Object *sync, OOP_Object *pixfmt, struct ModeInfo *modeinfo)
 507 {
 508     struct LibResolution *node;
 509     IPTR width, height, depth;
 510
 511     OOP_GetAttr(sync, aHidd_Sync_HDisp, &width);
 512     OOP_GetAttr(sync, aHidd_Sync_VDisp, &height);
 513     OOP_GetAttr(pixfmt, aHidd_PixFmt_Depth, &depth);
 514
 515     D(bug("getrtgmodeinfo %dx%dx%d\n", width, height, depth));
 516     // UAE RTG driver does not need anything else
 517     // but real RTG does
 518     ForeachNode((csd->boardinfo + PSSO_BoardInfo_ResolutionsList), node) {
 519         if (node->Width == width && node->Height == height) {
 520             UBYTE index = (depth + 7) / 8;
 521             if (node->Modes[index]) {
 522                 D(bug("RTG ModeInfo found %p\n", node->Modes[index]));
 523                 return node->Modes[index];
 524             }
 525         }
 526     }
 527     D(bug("using fake modeinfo\n"));
 528     modeinfo->Width = width;
 529     modeinfo->Height = height;
 530     modeinfo->Depth = depth;
 531     return modeinfo;
 532 }
 533
 534 const UBYTE modetable[16] =
 535         {  0, 8, 4, 12,  2, 10, 6, 14,  7, 9, 5, 13,  3, 11, 1, 15 };
 536
 537 APTR gp(UBYTE *p)
 538 {
 539     return ((APTR*)p)[0];
 540 }
 541 ULONG gl(UBYTE *p)
 542 {
 543     return ((ULONG*)p)[0];
 544 }
 545 UWORD gw(UBYTE *p)
 546 {
 547     return ((UWORD*)p)[0];
 548 }
 549 void pp(UBYTE *p, APTR a)
 550 {
 551     ((APTR*)p)[0] = a;
 552 }
 553 void pl(UBYTE *p, ULONG l)
 554 {
 555     ((ULONG*)p)[0] = l;
 556 }
 557 void pw(UBYTE *p, WORD w)
 558 {
 559     ((WORD*)p)[0] = w;
 560 }
 561 void pb(UBYTE *p, BYTE b)
 562 {
 563     ((BYTE*)p)[0] = b;
 564 }