![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to screen.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [HATARI the Atari ST Emulator] / hatari / src|
Return to screen.c CVS log | Up to [HATARI the Atari ST Emulator] / hatari / src |
1.1 ! root 1: /* ! 2: Hatari ! 3: ! 4: This code converts a 1/2/4 plane ST format screen to either 8 or 16-bit PC format. An awful ! 5: lost of processing is needed to do this conversion - we cannot simply change palettes on ! 6: interrupts under Windows as is possible with DOS. ! 7: The main code processes the palette/resolution mask tables to find exactly which lines ! 8: need to updating and the conversion routines themselves only update 16-pixel blocks ! 9: which differ from the previous frame - this gives a large performance increase. ! 10: Each conversion routine can convert any part of the source ST screen(which includes the ! 11: overscan border, usually set to colour zero) so they can be used for both Window and ! 12: full-screen. ! 13: Note that in Hi-Resolution we have no overscan and just two colours so we can optimise ! 14: things further. Also when running in maximum speed we make sure we only convert the screen ! 15: every 50 times a second - inbetween frames are not processed. ! 16: */ ! 17: ! 18: #include <SDL.h> ! 19: ! 20: #include "main.h" ! 21: #include "dialog.h" ! 22: /*#include "dsurface.h"*/ ! 23: #include "ikbd.h" ! 24: #include "m68000.h" ! 25: #include "memAlloc.h" ! 26: #include "misc.h" ! 27: #include "pcx.h" ! 28: #include "printer.h" ! 29: #include "screen.h" ! 30: #include "screenConvert.h" ! 31: #include "screenDraw.h" ! 32: #include "screenSnapShot.h" ! 33: #include "sound.h" ! 34: #include "spec512.h" ! 35: #include "statusBar.h" ! 36: #include "vdi.h" ! 37: #include "video.h" ! 38: #include "view.h" ! 39: ! 40: ! 41: /* FIXME */ ! 42: //BMP ScreenBMP; /* Screen bitmap details used for blitting to window */ ! 43: SCREENDRAW ScreenDrawWindow[4]; /* Set up with details of drawing functions for ST_xxx_RES */ ! 44: SCREENDRAW ScreenDrawFullScreen[4]; /* And for full-screen */ ! 45: SCREENDRAW ScreenDrawVDIWindow[4]; ! 46: SCREENDRAW ScreenDrawVDIFullScreen[4]; /* And for full-screen */ ! 47: FRAMEBUFFER FrameBuffers[NUM_FRAMEBUFFERS]; /* Store frame buffer details to tell how to update */ ! 48: FRAMEBUFFER *pFrameBuffer; /* Pointer into current 'FrameBuffer' */ ! 49: unsigned char *pScreenBitmap=NULL; /* Screen pixels in PC RGB format, allocated with 'CreateDIBSection' */ ! 50: unsigned char *pSTScreen,*pSTScreenCopy; /* Keep track of current and previous ST screen data */ ! 51: unsigned char *pPCScreenDest; /* Destination PC buffer */ ! 52: int STScreenStartHorizLine,STScreenEndHorizLine; /* Start/End lines to be converted */ ! 53: int PCScreenBytesPerLine,STScreenWidthBytes,STScreenLeftSkipBytes; ! 54: BOOL bInFullScreen=FALSE; /* TRUE if in full screen */ ! 55: BOOL bFullScreenHold = FALSE; /* TRUE if hold display while full screen */ ! 56: BOOL bScreenContentsChanged; /* TRUE if buffer changed and requires blitting */ ! 57: //int STRes=ST_HIGH_RES,PrevSTRes=ST_HIGH_RES; /* Current and previous ST resolutions */ ! 58: int STRes=ST_LOW_RES,PrevSTRes=ST_LOW_RES; /* Current and previous ST resolutions */ ! 59: volatile int VBLCounter=0; /* VBL counters (volatile as used in interrupts) */ ! 60: volatile int OldVBLCounter=0; ! 61: int nDroppedFrames=0; /* Number of dropped frames during emulation run */ ! 62: ! 63: int STScreenLineOffset[NUM_VISIBLE_LINES]; /* Offsets for ST screen lines eg, 0,160,320... */ ! 64: unsigned long STRGBPalette[16]; /* Palette buffer used in assembler conversion routines */ ! 65: unsigned long ST2RGB[2048]; /* Table to convert ST Palette 0x777 to PC format RGB551(2 pixels each entry) */ ! 66: unsigned short int HBLPalette[16], PrevHBLPalette[16]; /* Current palette for line, also copy of first line */ ! 67: ! 68: SDL_Surface *sdlscrn; ! 69: extern bUseFullscreen; ! 70: ! 71: ! 72: /*-----------------------------------------------------------------------*/ ! 73: /* ! 74: Init Screen bitmap and buffers/tables needed for ST to PC screen conversion ! 75: */ ! 76: void Screen_Init(void) ! 77: { ! 78: int i; ! 79: ! 80: /* New: SDL init stuff! */ ! 81: if( SDL_Init(SDL_INIT_VIDEO|SDL_INIT_AUDIO) < 0 ) ! 82: { ! 83: fprintf(stderr, "Could not initialize the SDL library:\n %s\n", SDL_GetError() ); ! 84: exit(-1); ! 85: } ! 86: ! 87: /* Clear frame buffer structures and set current pointer */ ! 88: Memory_Clear(FrameBuffers,sizeof(FRAMEBUFFER)*2); ! 89: ! 90: /* Allocate previous screen check workspace. We are going to double-buffer a double-buffered screen. Oh. */ ! 91: for(i=0; i<NUM_FRAMEBUFFERS; i++) { ! 92: FrameBuffers[i].pSTScreen = (unsigned char *)Memory_Alloc(((MAX_VDI_WIDTH*MAX_VDI_PLANES)/8)*MAX_VDI_HEIGHT); ! 93: FrameBuffers[i].pSTScreenCopy = (unsigned char *)Memory_Alloc(((MAX_VDI_WIDTH*MAX_VDI_PLANES)/8)*MAX_VDI_HEIGHT); ! 94: } ! 95: pFrameBuffer = &FrameBuffers[0]; ! 96: ! 97: if (bUseVDIRes) ! 98: Screen_AllocateScreenBitmap(VDIWidth,VDIHeight,bUseHighRes ? 1:8); /* Allocate windows bitmap, for VDI */ ! 99: else ! 100: { ! 101: if(bUseHighRes) ! 102: Screen_AllocateScreenBitmap(640,400,8); /* Allocate windows bitmap */ ! 103: else ! 104: Screen_AllocateScreenBitmap(320,200,16); /* Allocate windows bitmap, 320x200x16bit(with overscan) */ ! 105: } ! 106: ! 107: Video_SetScreenRasters(); /* Set rasters ready for first screen */ ! 108: ! 109: Screen_SetScreenLineOffsets(); /* Store offset to each horizontal line */ ! 110: Screen_SetDrawModes(); /* Set draw modes */ ! 111: Screen_SetupRGBTable(FALSE); /* Window */ ! 112: Screen_SetFullUpdate(); /* Cause full update of screen */ ! 113: ! 114: SDL_WM_SetCaption(PROG_NAME, "Hatari"); ! 115: SDL_EventState(SDL_MOUSEMOTION, SDL_ENABLE); ! 116: SDL_EventState(SDL_MOUSEBUTTONDOWN, SDL_ENABLE); ! 117: SDL_EventState(SDL_MOUSEBUTTONUP, SDL_ENABLE); ! 118: } ! 119: ! 120: /*-----------------------------------------------------------------------*/ ! 121: /* ! 122: Free screen bitmap and allocated resources ! 123: */ ! 124: void Screen_UnInit(void) ! 125: { ! 126: int i; ! 127: ! 128: /* Free memory used for ST screen bitmap */ ! 129: //FIXME DeleteObject(hBitmap); ! 130: ! 131: /* And for copies */ ! 132: for(i=0; i<NUM_FRAMEBUFFERS; i++) { ! 133: Memory_Free(FrameBuffers[i].pSTScreen); ! 134: Memory_Free(FrameBuffers[i].pSTScreenCopy); ! 135: } ! 136: ! 137: SDL_Quit(); ! 138: } ! 139: ! 140: /*-----------------------------------------------------------------------*/ ! 141: /* ! 142: Reset screen ! 143: */ ! 144: void Screen_Reset(void) ! 145: { ! 146: /* On re-boot, always correct ST resolution for monitor, eg Colour/Mono */ ! 147: if (bUseVDIRes) { ! 148: STRes = VDIRes; ! 149: } ! 150: else { ! 151: if (bUseHighRes) ! 152: STRes = ST_HIGH_RES; ! 153: else ! 154: STRes = ST_LOW_RES; ! 155: } ! 156: PrevSTRes = -1; ! 157: /* Cause full update */ ! 158: Screen_SetFullUpdate(); ! 159: } ! 160: ! 161: /*-----------------------------------------------------------------------*/ ! 162: /* ! 163: Store Y offset for each horizontal line in our source ST screen for each reference in assembler(no multiply) ! 164: */ ! 165: void Screen_SetScreenLineOffsets(void) ! 166: { ! 167: int i; ! 168: ! 169: for(i=0; i<NUM_VISIBLE_LINES; i++) ! 170: STScreenLineOffset[i] = i * SCREENBYTES_LINE; ! 171: } ! 172: ! 173: /*-----------------------------------------------------------------------*/ ! 174: /* ! 175: Set details of BMP header ! 176: */ ! 177: /* FIXME */ ! 178: /* ! 179: void Screen_SetBMPHeaders(BMP *pBMP,int Width,int Height,int BitCount) ! 180: { ! 181: pBMP->FileHeader.bfType = 0x4d42; ! 182: pBMP->FileHeader.bfSize = 0; ! 183: pBMP->FileHeader.bfReserved1 = 0; ! 184: pBMP->FileHeader.bfReserved2 = 0; ! 185: if (BitCount==1) ! 186: pBMP->FileHeader.bfOffBits = sizeof(BITMAPFILEHEADER) + sizeof(BITMAPINFOHEADER) + (sizeof(RGBQUAD)*2); ! 187: else if (BitCount==8) ! 188: pBMP->FileHeader.bfOffBits = sizeof(BITMAPFILEHEADER) + sizeof(BITMAPINFOHEADER) + (sizeof(RGBQUAD)*256); ! 189: else ! 190: pBMP->FileHeader.bfOffBits = sizeof(BITMAPFILEHEADER) + sizeof(BITMAPINFOHEADER); ! 191: // And BMP InfoHeader ! 192: pBMP->InfoHeader.biSize = sizeof(BITMAPINFOHEADER); ! 193: pBMP->InfoHeader.biWidth = Width; ! 194: pBMP->InfoHeader.biHeight = -Height; // SetDIBits reverses Y; places 0,0 top left ! 195: pBMP->InfoHeader.biBitCount = BitCount; ! 196: pBMP->InfoHeader.biPlanes = 1; ! 197: pBMP->InfoHeader.biCompression = BI_RGB; ! 198: pBMP->InfoHeader.biSizeImage = ((Width*Height)*BitCount)/8; ! 199: pBMP->InfoHeader.biXPelsPerMeter = 1; ! 200: pBMP->InfoHeader.biYPelsPerMeter = 1; ! 201: pBMP->InfoHeader.biClrUsed = 0; ! 202: pBMP->InfoHeader.biClrImportant = 0; ! 203: } ! 204: */ ! 205: ! 206: /*-----------------------------------------------------------------------*/ ! 207: /* ! 208: Set flags so screen will be TOTALLY re-drawn(clears whole of full-screen) next time around ! 209: */ ! 210: void Screen_SetFullUpdate(void) ! 211: { ! 212: int i; ! 213: ! 214: /* Update frame buffers */ ! 215: for(i=0; i<NUM_FRAMEBUFFERS; i++) ! 216: FrameBuffers[i].bFullUpdate = TRUE; ! 217: } ! 218: ! 219: /*-----------------------------------------------------------------------*/ ! 220: /* ! 221: Create ST 777 colour format to 16-bits per pixel - call each time change resolution or to/from Window display ! 222: */ ! 223: void Screen_SetupRGBTable(BOOL bFullScreen) ! 224: { ! 225: unsigned int STColour,RGBColour; ! 226: unsigned int r,g,b; ! 227: ! 228: /* Do Red,Green and Blue for all 512 ST colours */ ! 229: for(r=0; r<8; r++) { ! 230: for(g=0; g<8; g++) { ! 231: for(b=0; b<8; b++) { ! 232: STColour = (r<<8) | (g<<4) | (b); /* ST format 0x777 */ ! 233: ! 234: /*RGBColour = (r<<12) | (g<<7) | (b<<2);*/ /* format 0x1555 */ ! 235: RGBColour = SDL_MapRGB(sdlscrn->format, (r<<5), (g<<5), (b<<5)); ! 236: ! 237: ST2RGB[STColour] = (RGBColour<<16) | RGBColour; /* As long's, for speed(write two pixels at once) */ ! 238: } ! 239: } ! 240: } ! 241: } ! 242: ! 243: /*-----------------------------------------------------------------------*/ ! 244: /* ! 245: Enter Full screen mode ! 246: */ ! 247: void Screen_EnterFullScreen(void) ! 248: { ! 249: BOOL bRet; ! 250: ! 251: if (!bInFullScreen) { ! 252: Main_PauseEmulation(); /* Hold things... */ ! 253: //FIXME Sleep(20); /* To give sound time to clear! */ ! 254: ! 255: Screen_SetDrawModes(); /* Set draw modes(store which DirectDraw modes to use!) */ ! 256: /* Select full-screen for standard or VDI resolution */ ! 257: if (bUseVDIRes) ! 258: bRet = 0/*DSurface_EnterDDrawFullScreen(ScreenDrawVDIFullScreen[VDIRes].DirectDrawMode)*/; ! 259: else ! 260: bRet = 0/*DSurface_EnterDDrawFullScreen(ScreenDrawFullScreen[STRes].DirectDrawMode)*/; ! 261: if (bRet) { ! 262: //FIXME View_ToggleWindowsMouse(MOUSE_ST); /* Put mouse into ST mode */ ! 263: //FIXME View_LimitCursorToScreen(); /* Free mouse from Window constraints */ ! 264: Screen_SetupRGBTable(TRUE); /* Set full screen RGB */ ! 265: Screen_SetFullUpdate(); /* Cause full update of screen */ ! 266: Screen_Clear_Window(); /* Black out Window's bitmap as will be invalid when return */ ! 267: } ! 268: Main_UnPauseEmulation(); /* And off we go... */ ! 269: } ! 270: } ! 271: ! 272: /*-----------------------------------------------------------------------*/ ! 273: /* ! 274: Return from Full screen mode back to a window ! 275: */ ! 276: void Screen_ReturnFromFullScreen(void) ! 277: { ! 278: if (bInFullScreen) { ! 279: Main_PauseEmulation(); // Hold things... ! 280: //FIXME Sleep(20); // To give sound time to clear! ! 281: /* ! 282: if (DSurface_ReturnFromDDrawFullScreen()) { ! 283: //FIXME View_ResizeWindowToFull(); // Resize window to ST screen size ! 284: //FIXME View_LimitCursorToClient(); // And limit mouse in Window ! 285: Screen_SetupRGBTable(FALSE); // Set window RGB ! 286: Screen_SetFullUpdate(); // Cause full update of screen ! 287: } ! 288: */ ! 289: //FIXME View_ToggleWindowsMouse(MOUSE_ST); // Put mouse into ST mode ! 290: Main_UnPauseEmulation(); // And off we go... ! 291: // View_Update(); // And refresh screen ! 292: } ! 293: } ! 294: ! 295: //----------------------------------------------------------------------- ! 296: /* ! 297: Clear Window display memory ! 298: */ ! 299: void Screen_Clear_Window(void) ! 300: { ! 301: SDL_FillRect(sdlscrn,NULL, SDL_MapRGB(sdlscrn->format, 255, 255, 255) ); ! 302: } ! 303: ! 304: //----------------------------------------------------------------------- ! 305: /* ! 306: Clear full screen display. Used as full-screen has changing top/bottom borders and also interlaced modes ! 307: */ ! 308: void Screen_Clear_FullScreen(void) ! 309: { ! 310: /* FIXME */ ! 311: /* ! 312: SCREENDRAW *pScreenDraw; ! 313: unsigned char *pSurface; ! 314: int y,nWidthBytes; ! 315: ! 316: // Clear whole screen ! 317: if (bUseVDIRes) ! 318: pScreenDraw = &ScreenDrawVDIFullScreen[VDIRes]; ! 319: else ! 320: pScreenDraw = &ScreenDrawFullScreen[STRes]; ! 321: pSurface = (unsigned char *)Surface.lpSurface; ! 322: nWidthBytes = pScreenDraw->Width*(pScreenDraw->BitDepth/8); ! 323: // One line at a time ! 324: for(y=0; y<pScreenDraw->Height; y++) { ! 325: Memory_Clear(pSurface,nWidthBytes); ! 326: pSurface += Surface.lPitch; ! 327: } ! 328: */ ! 329: } ! 330: ! 331: //----------------------------------------------------------------------- ! 332: /* ! 333: Set ScreenDrawFullScreen[] and ScreenDrawWindow[] arrays with information for chosen display modes ! 334: */ ! 335: void Screen_SetDrawModes(void) ! 336: { ! 337: SCREENDRAW_DISPLAYOPTIONS *pScreenDisplay; ! 338: ! 339: /* Clear out */ ! 340: Memory_Clear(ScreenDrawWindow,sizeof(SCREENDRAW)*4); ! 341: Memory_Clear(ScreenDrawFullScreen,sizeof(SCREENDRAW)*4); ! 342: Memory_Clear(ScreenDrawVDIWindow,sizeof(SCREENDRAW)*4); ! 343: Memory_Clear(ScreenDrawVDIFullScreen,sizeof(SCREENDRAW)*4); ! 344: ! 345: /* First, store Window details(set for 16-bit Windows desktop) */ ! 346: ScreenDrawWindow[ST_LOW_RES].pDrawFunction = ConvertLowRes_320x16Bit; ! 347: ScreenDrawWindow[ST_LOW_RES].Width = 320; ScreenDrawWindow[ST_LOW_RES].Height = 200; ScreenDrawWindow[ST_LOW_RES].BitDepth = 16; ! 348: ! 349: ScreenDrawWindow[ST_MEDIUM_RES].pDrawFunction = ConvertMediumRes_640x16Bit; ! 350: ScreenDrawWindow[ST_MEDIUM_RES].Width = 640; ScreenDrawWindow[ST_MEDIUM_RES].Height = 200; ScreenDrawWindow[ST_MEDIUM_RES].BitDepth = 16; ! 351: /* ! 352: ScreenDrawWindow[ST_HIGH_RES].pDrawFunction = ConvertHighRes_640x1Bit; ! 353: ScreenDrawWindow[ST_HIGH_RES].Width = 640; ScreenDrawWindow[ST_HIGH_RES].Height = 400; ScreenDrawWindow[ST_HIGH_RES].BitDepth = 1; ! 354: */ ! 355: ScreenDrawWindow[ST_HIGH_RES].pDrawFunction = ConvertHighRes_640x8Bit; ! 356: ScreenDrawWindow[ST_HIGH_RES].Width = 640; ScreenDrawWindow[ST_HIGH_RES].Height = 400; ScreenDrawWindow[ST_HIGH_RES].BitDepth = 8; ! 357: ! 358: /* (NOTE this is irrelevant as is directed to low/medium when starts) */ ! 359: ScreenDrawWindow[ST_LOWMEDIUM_MIX_RES].pDrawFunction = ConvertLowRes_640x16Bit; ! 360: ScreenDrawWindow[ST_LOWMEDIUM_MIX_RES].Width = 640; ScreenDrawWindow[ST_LOWMEDIUM_MIX_RES].Height = 200; ScreenDrawWindow[ST_LOWMEDIUM_MIX_RES].BitDepth = 16; ! 361: ! 362: /* And for VDI screens(set for 8-bit) */ ! 363: ScreenDrawVDIWindow[ST_LOW_RES].pDrawFunction = ConvertVDIRes_16Colour; ! 364: ScreenDrawVDIWindow[ST_LOW_RES].Width = VDIWidth; ScreenDrawVDIWindow[ST_LOW_RES].Height = VDIHeight; ScreenDrawVDIWindow[ST_LOW_RES].BitDepth = 8; ! 365: ScreenDrawVDIWindow[ST_MEDIUM_RES].pDrawFunction = ConvertVDIRes_4Colour; ! 366: ScreenDrawVDIWindow[ST_MEDIUM_RES].Width = VDIWidth; ScreenDrawVDIWindow[ST_MEDIUM_RES].Height = VDIHeight; ScreenDrawVDIWindow[ST_MEDIUM_RES].BitDepth = 8; ! 367: ScreenDrawVDIWindow[ST_HIGH_RES].pDrawFunction = ConvertVDIRes_2Colour_1Bit; ! 368: ScreenDrawVDIWindow[ST_HIGH_RES].Width = VDIWidth; ScreenDrawVDIWindow[ST_HIGH_RES].Height = VDIHeight; ScreenDrawVDIWindow[ST_HIGH_RES].BitDepth = 1; ! 369: ! 370: /* And full-screen, select from Overscan/Non-Overscan */ ! 371: /* FIXME */ ! 372: /* ! 373: if (ConfigureParams.Screen.Advanced.bAllowOverscan) ! 374: pScreenDisplay = &ScreenDisplayOptions[ConfigureParams.Screen.ChosenDisplayMode]; ! 375: else*/ ! 376: pScreenDisplay = &ScreenDisplayOptions_NoOverscan[0/*FIXME:*//*ConfigureParams.Screen.ChosenDisplayMode*/]; ! 377: ! 378: ! 379: /* Assign full-screen draw modes from chosen option under dialog */ ! 380: ScreenDrawFullScreen[ST_LOW_RES] = *pScreenDisplay->pLowRes; ! 381: ScreenDrawFullScreen[ST_MEDIUM_RES] = *pScreenDisplay->pMediumRes; ! 382: ScreenDrawFullScreen[ST_HIGH_RES] = *pScreenDisplay->pHighRes; ! 383: ScreenDrawFullScreen[ST_LOWMEDIUM_MIX_RES] = *pScreenDisplay->pLowMediumMixRes; ! 384: /* Check we do have mode to run, else choose alternative(MUST have one or other else option would be disabled) */ ! 385: /* ! 386: if (!bAvailableDDrawModes[ ScreenDrawFullScreen[ST_LOW_RES].DirectDrawMode ]) ! 387: ScreenDrawFullScreen[ST_LOW_RES] = *pScreenDisplay->pAltLowRes; ! 388: if (!bAvailableDDrawModes[ ScreenDrawFullScreen[ST_MEDIUM_RES].DirectDrawMode ]) ! 389: ScreenDrawFullScreen[ST_MEDIUM_RES] = *pScreenDisplay->pAltMediumRes; ! 390: if (!bAvailableDDrawModes[ ScreenDrawFullScreen[ST_HIGH_RES].DirectDrawMode ]) ! 391: ScreenDrawFullScreen[ST_HIGH_RES] = *pScreenDisplay->pAltHighRes; ! 392: if (!bAvailableDDrawModes[ ScreenDrawFullScreen[ST_LOWMEDIUM_MIX_RES].DirectDrawMode ]) ! 393: ScreenDrawFullScreen[ST_LOWMEDIUM_MIX_RES] = *pScreenDisplay->pAltLowMediumMixRes; ! 394: */ ! 395: /* And VDI(8-bit), according to select resolution */ ! 396: switch(VDIWidth) { ! 397: case 640: ! 398: ScreenDrawVDIFullScreen[ST_LOW_RES] = VDIScreenDraw_640x480[0]; ! 399: ScreenDrawVDIFullScreen[ST_MEDIUM_RES] = VDIScreenDraw_640x480[1]; ! 400: ScreenDrawVDIFullScreen[ST_HIGH_RES] = VDIScreenDraw_640x480[2]; ! 401: break; ! 402: case 800: ! 403: ScreenDrawVDIFullScreen[ST_LOW_RES] = VDIScreenDraw_800x600[0]; ! 404: ScreenDrawVDIFullScreen[ST_MEDIUM_RES] = VDIScreenDraw_800x600[1]; ! 405: ScreenDrawVDIFullScreen[ST_HIGH_RES] = VDIScreenDraw_800x600[2]; ! 406: break; ! 407: case 1024: ! 408: ScreenDrawVDIFullScreen[ST_LOW_RES] = VDIScreenDraw_1024x768[0]; ! 409: ScreenDrawVDIFullScreen[ST_MEDIUM_RES] = VDIScreenDraw_1024x768[1]; ! 410: ScreenDrawVDIFullScreen[ST_HIGH_RES] = VDIScreenDraw_1024x768[2]; ! 411: break; ! 412: } ! 413: } ! 414: ! 415: /*-----------------------------------------------------------------------*/ ! 416: /* ! 417: Allocate memory to store ST screen ready for Windows 'Blit' ! 418: */ ! 419: extern int CurrentDisplayMode; ! 420: ! 421: void Screen_AllocateScreenBitmap(int Width,int Height,int BitCount) ! 422: { ! 423: long Size; ! 424: SDL_Color cols[2]; ! 425: ! 426: // Do we already have a screen allocated? If so, free ! 427: // if (pScreenBitmap) ! 428: // DeleteObject(hBitmap); ! 429: ! 430: // Adjust width/height for overscan borders, if mono or VDI we have no overscan ! 431: if ( !(bUseVDIRes || bUseHighRes) ) { ! 432: // If using 640 pixel wide screen, double overscan ! 433: if (Width==640) { ! 434: Width += OVERSCAN_LEFT+OVERSCAN_RIGHT; ! 435: Height += OVERSCAN_TOP+OVERSCAN_BOTTOM; ! 436: } ! 437: // Add in overscan borders(if 640x200 bitmap is double on Y) ! 438: Width += OVERSCAN_LEFT+OVERSCAN_RIGHT; ! 439: Height += OVERSCAN_TOP+OVERSCAN_BOTTOM; ! 440: } ! 441: ! 442: // Allocate bitmap for screen ! 443: Size = ((Width*Height)*BitCount)/8; ! 444: ! 445: // Set BMP FileHeader ! 446: // Screen_SetBMPHeaders(&ScreenBMP, Width,Height,BitCount); ! 447: ! 448: // Create memory for bitmap, use 'CreateDIBSection' as faster than normal 'alloc' on some systems ! 449: /*hBitmap = CreateDIBSection(MainDC,(BITMAPINFO *)&ScreenBMP.InfoHeader,DIB_RGB_COLORS,(void **)&pScreenBitmap,0,0);*/ ! 450: ! 451: fprintf(stderr, "Video mode: Width=%i Height=%i bpp=%i\n", Width, Height, BitCount); ! 452: if(bUseFullscreen) ! 453: sdlscrn=SDL_SetVideoMode(Width, Height, BitCount, SDL_SWSURFACE|SDL_HWPALETTE|SDL_FULLSCREEN); ! 454: else ! 455: sdlscrn=SDL_SetVideoMode(Width, Height, BitCount, SDL_SWSURFACE|SDL_HWPALETTE); ! 456: if( sdlscrn==NULL ) ! 457: { ! 458: fprintf(stderr, "Could not set video mode:\n %s\n", SDL_GetError() ); ! 459: exit(-2); ! 460: } ! 461: pScreenBitmap=sdlscrn->pixels; ! 462: ! 463: cols[0].r=0; cols[0].g=0; cols[0].b=0; ! 464: cols[1].r=255; cols[1].g=255; cols[1].b=255; ! 465: SDL_SetColors(sdlscrn, cols, 0, 2); /* Quick and dirty hack - remove it later */ ! 466: } ! 467: ! 468: ! 469: //----------------------------------------------------------------------- ! 470: /* ! 471: Have we changes beteen low/medium/high res? ! 472: */ ! 473: void Screen_DidResolutionChange(void) ! 474: { ! 475: BOOL bRet; ! 476: ! 477: // Did change res? ! 478: if (STRes!=PrevSTRes) { ! 479: // We've changed, allocate new Windows bitmap ! 480: ! 481: // VDI or standard ST resolution? ! 482: if (bUseVDIRes) { ! 483: // Allocate to set VDI resolution ! 484: Screen_AllocateScreenBitmap(VDIWidth,VDIHeight,bUseHighRes ? 1:8); ! 485: } ! 486: else { ! 487: // Allocate accordingly to STRes(may be mix of low/medium) ! 488: switch(STRes) { ! 489: case ST_LOW_RES: ! 490: Screen_AllocateScreenBitmap(320,200,16); ! 491: break; ! 492: case ST_MEDIUM_RES: ! 493: case ST_LOWMEDIUM_MIX_RES: ! 494: Screen_AllocateScreenBitmap(640,400,16); ! 495: break; ! 496: case ST_HIGH_RES: ! 497: Screen_AllocateScreenBitmap(640,400,8); ! 498: break; ! 499: } ! 500: } ! 501: ! 502: // Set new DirectDraw display mode, if differs from current ! 503: /* ! 504: if (bInFullScreen) { ! 505: if (bUseVDIRes) ! 506: bRet = DSurface_EnterDDrawFullScreen(ScreenDrawVDIFullScreen[VDIRes].DirectDrawMode); ! 507: else ! 508: bRet = DSurface_EnterDDrawFullScreen(ScreenDrawFullScreen[STRes].DirectDrawMode); ! 509: if (bRet) ! 510: Screen_SetFullUpdate(); ! 511: } ! 512: */ ! 513: // else // If not in full screen, resize window ! 514: //FIXME View_ResizeWindowToFull(); ! 515: ! 516: PrevSTRes = STRes; ! 517: Screen_SetFullUpdate(); ! 518: } ! 519: ! 520: // Did change overscan mode? Causes full update ! 521: if (pFrameBuffer->OverscanModeCopy!=OverscanMode) ! 522: pFrameBuffer->bFullUpdate = TRUE; ! 523: } ! 524: ! 525: //----------------------------------------------------------------------- ! 526: /* ! 527: Compare current resolution on line with previous, and set 'UpdateLine' accordingly ! 528: Also check if swap between low/medium resolution and return in 'bLowMedMix' ! 529: */ ! 530: void Screen_CompareResolution(int y, int *pUpdateLine, BOOL *pbLowMedMix) ! 531: { ! 532: BOOL bResChanged=FALSE; ! 533: int Resolution; ! 534: ! 535: // Check if wrote to resolution register ! 536: if (HBLPaletteMasks[y]&PALETTEMASK_RESOLUTION) { // See 'Intercept_ShifterMode_WriteByte' ! 537: Resolution = (HBLPaletteMasks[y]>>16)&0x1; ! 538: // Have used any low/medium res mix? ! 539: if (Resolution!=(STRes&0x1)) ! 540: *pbLowMedMix = TRUE; ! 541: // Did change resolution ! 542: if (Resolution!=(int)((pFrameBuffer->HBLPaletteMasks[y]>>16)&0x1)) ! 543: *pUpdateLine |= PALETTEMASK_UPDATERES; ! 544: else ! 545: *pUpdateLine &= ~PALETTEMASK_UPDATERES; ! 546: } ! 547: } ! 548: ! 549: //----------------------------------------------------------------------- ! 550: /* ! 551: Check to see if palette changes cause screen update and keep 'HBLPalette[]' up-to-date ! 552: */ ! 553: void Screen_ComparePalette(int y, int *pUpdateLine) ! 554: { ! 555: BOOL bPaletteChanged = FALSE; ! 556: int i; ! 557: ! 558: // Did write to palette in this or previous frame? ! 559: if (((HBLPaletteMasks[y]|pFrameBuffer->HBLPaletteMasks[y])&PALETTEMASK_PALETTE)!=0) { ! 560: // Check and update ones which changed ! 561: for(i=0; i<16; i++) { ! 562: if (HBLPaletteMasks[y]&(1<<i)) // Update changes in ST palette ! 563: HBLPalette[i] = HBLPalettes[(y*16)+i]; ! 564: } ! 565: // Now check with same palette from previous frame for any differences(may be changing palette back) ! 566: for(i=0; (i<16) && (!bPaletteChanged); i++) { ! 567: if (HBLPalette[i]!=pFrameBuffer->HBLPalettes[(y*16)+i]) ! 568: bPaletteChanged = TRUE; ! 569: } ! 570: if (bPaletteChanged) ! 571: *pUpdateLine |= PALETTEMASK_UPDATEPAL; ! 572: else ! 573: *pUpdateLine &= ~PALETTEMASK_UPDATEPAL; ! 574: } ! 575: } ! 576: ! 577: //----------------------------------------------------------------------- ! 578: /* ! 579: Check for differences in Palette and Resolution from Mask table and update and ! 580: store off which lines need updating and create full-screen palette. ! 581: (It is very important for these routines to check for colour changes with the previous ! 582: screen so only the very minimum parts are updated) ! 583: */ ! 584: int Screen_ComparePaletteMask(void) ! 585: { ! 586: BOOL bLowMedMix=FALSE; ! 587: int LineUpdate = 0; ! 588: int y; ! 589: ! 590: /* Set for monochrome? */ ! 591: if (bUseHighRes) { ! 592: OverscanMode = OVERSCANMODE_NONE; ! 593: /* Colours changed? */ ! 594: if (HBLPalettes[0]!=PrevHBLPalette[0]) ! 595: pFrameBuffer->bFullUpdate = TRUE; ! 596: ! 597: /* Just copy mono colours */ ! 598: if (HBLPalettes[0]&0x777) { ! 599: HBLPalettes[0] = 0x777; HBLPalettes[1] = 0x000; ! 600: } ! 601: else { ! 602: HBLPalettes[0] = 0x000; HBLPalettes[1] = 0x777; ! 603: } ! 604: ! 605: /* Set bit to flag 'full update' */ ! 606: if (pFrameBuffer->bFullUpdate) ! 607: ScrUpdateFlag = PALETTEMASK_UPDATEFULL; ! 608: else ! 609: ScrUpdateFlag = 0x00000000; ! 610: } ! 611: ! 612: /* Use VDI resolution? */ ! 613: if (bUseVDIRes) { ! 614: /* Force to VDI resolution screen, without overscan */ ! 615: STRes = VDIRes; ! 616: ! 617: /* Colours changed? */ ! 618: if (HBLPalettes[0]!=PrevHBLPalette[0]) ! 619: pFrameBuffer->bFullUpdate = TRUE; ! 620: ! 621: /* Set bit to flag 'full update' */ ! 622: if (pFrameBuffer->bFullUpdate) ! 623: ScrUpdateFlag = PALETTEMASK_UPDATEFULL; ! 624: else ! 625: ScrUpdateFlag = 0x00000000; ! 626: } ! 627: /* Are in Mono? Force to monochrome and no overscan */ ! 628: else if (bUseHighRes) { ! 629: /* Force to standard hi-resolution screen, without overscan */ ! 630: STRes = ST_HIGH_RES; ! 631: } ! 632: else { /* Full colour */ ! 633: /* Get resolution */ ! 634: STRes = (HBLPaletteMasks[0]>>16)&0x3; ! 635: /* Do all lines - first is tagged as full-update */ ! 636: for(y=0; y<NUM_VISIBLE_LINES; y++) { ! 637: /* Find any resolution/palette change and update palette/mask buffer */ ! 638: /* ( LineUpdate has top two bits set to say if line needs updating due to palette or resolution change ) */ ! 639: Screen_CompareResolution(y,&LineUpdate,&bLowMedMix); ! 640: Screen_ComparePalette(y,&LineUpdate); ! 641: HBLPaletteMasks[y] = (HBLPaletteMasks[y]&(~PALETTEMASK_UPDATEMASK)) | LineUpdate; ! 642: /* Copy palette and mask for next frame */ ! 643: memcpy(&pFrameBuffer->HBLPalettes[y*16],HBLPalette,sizeof(short int)*16); ! 644: pFrameBuffer->HBLPaletteMasks[y] = HBLPaletteMasks[y]; ! 645: } ! 646: /* Did mix resolution? */ ! 647: if (bLowMedMix) ! 648: STRes = ST_LOWMEDIUM_MIX_RES; ! 649: } ! 650: ! 651: return(STRes); ! 652: } ! 653: ! 654: //----------------------------------------------------------------------- ! 655: /* ! 656: Create 8-Bit palette for display if needed ! 657: */ ! 658: void Screen_CreatePalette(void) ! 659: { ! 660: /* FIXME */ ! 661: /* ! 662: int i; ! 663: ! 664: // Full screen, or Window? ! 665: if (bInFullScreen) { ! 666: DSurface_SetPalette(); ! 667: } ! 668: else { ! 669: for(i=0; i<16; i++) { ! 670: ScreenBMP.Colours[i+10].rgbRed = ((HBLPalettes[i]>>8)&0x7)<<5; ! 671: ScreenBMP.Colours[i+10].rgbGreen = ((HBLPalettes[i]>>4)&0x7)<<5; ! 672: ScreenBMP.Colours[i+10].rgbBlue = (HBLPalettes[i]&0x7)<<5; ! 673: ScreenBMP.Colours[i+10].rgbReserved = 0; ! 674: } ! 675: } ! 676: */ ! 677: } ! 678: ! 679: //----------------------------------------------------------------------- ! 680: /* ! 681: Create 8-Bit palette for display if needed ! 682: */ ! 683: void Screen_Handle8BitPalettes(void) ! 684: { ! 685: BOOL bCheckPalette=FALSE,bPaletteChanged=FALSE; ! 686: int i; ! 687: ! 688: /* VDI screens are ALL 8-Bit, beit Window or full-screen */ ! 689: if (bUseVDIRes) { ! 690: bCheckPalette = TRUE; ! 691: } ! 692: else { ! 693: /* Are we using an 8-Bit display? */ ! 694: if (bInFullScreen) { ! 695: /* Check if using 8-Bit full-screen display */ ! 696: if (ScreenDrawFullScreen[STRes].BitDepth!=16) ! 697: bCheckPalette = TRUE; ! 698: } ! 699: } ! 700: ! 701: /* Do need to check for 8-Bit palette change? Ie, update whole screen */ ! 702: if (bCheckPalette) { ! 703: /* If using HiRes palette update with full update flag */ ! 704: if (!bUseHighRes) { ! 705: /* Check if palette of 16 colours changed from previous frame */ ! 706: for(i=0; (i<16) && (!bPaletteChanged); i++) { ! 707: /* Check with first line palette(stored in 'Screen_ComparePaletteMask') */ ! 708: if (HBLPalettes[i]!=PrevHBLPalette[i]) ! 709: bPaletteChanged = TRUE; ! 710: } ! 711: } ! 712: ! 713: /* Did palette change or do we require a full update? */ ! 714: if ( (bPaletteChanged) || (pFrameBuffer->bFullUpdate) ) { ! 715: /* Create palette, for Full-Screen of Window */ ! 716: Screen_CreatePalette(); ! 717: /* Make sure update whole screen */ ! 718: pFrameBuffer->bFullUpdate = TRUE; ! 719: } ! 720: } ! 721: ! 722: /* Copy old palette for 8-Bit compare as this routine writes over it */ ! 723: memcpy(PrevHBLPalette,HBLPalettes,sizeof(short int)*16); ! 724: } ! 725: ! 726: //----------------------------------------------------------------------- ! 727: /* ! 728: Update Palette Mask to show 'full-update' required. This is usually done after a resolution change ! 729: or when going between a Window and full-screen display ! 730: */ ! 731: void Screen_SetFullUpdateMask(void) ! 732: { ! 733: int y; ! 734: ! 735: for(y=0; y<NUM_VISIBLE_LINES; y++) ! 736: HBLPaletteMasks[y] |= PALETTEMASK_UPDATEFULL; ! 737: } ! 738: ! 739: //----------------------------------------------------------------------- ! 740: /* ! 741: Set details for ST screen conversion(Window version) ! 742: */ ! 743: void Screen_SetWindowConvertDetails(void) ! 744: { ! 745: // Reset Double Y, used for Window medium res' and in full screen ! 746: bScrDoubleY = FALSE; ! 747: if (/*ConfigureParams.Screen.*/bUseHighRes) { ! 748: pSTScreen = pFrameBuffer->pSTScreen; // Source in ST memory ! 749: pPCScreenDest = pScreenBitmap; ! 750: pFrameBuffer->OverscanModeCopy = OverscanMode = OVERSCANMODE_NONE; ! 751: } ! 752: else ! 753: { ! 754: // Always draw to WHOLE screen including ALL borders ! 755: STScreenLeftSkipBytes = 0; // Number of bytes to skip on ST screen for left(border) ! 756: STScreenWidthBytes = SCREENBYTES_LINE; // Number of horizontal bytes in our ST screen ! 757: ! 758: STScreenStartHorizLine = 0; // Full height ! 759: STScreenEndHorizLine = NUM_VISIBLE_LINES; ! 760: ! 761: pSTScreen = pFrameBuffer->pSTScreen; // Source in ST memory ! 762: pSTScreenCopy = pFrameBuffer->pSTScreenCopy; // Previous ST screen ! 763: if (bUseVDIRes) ! 764: PCScreenBytesPerLine = VDIWidth; ! 765: else { ! 766: PCScreenBytesPerLine = (SCREENBYTES_LINE*2)*sizeof(short int); ! 767: if (STRes!=ST_LOW_RES) // Bytes per line in PC screen are DOUBLE when in medium/mix ! 768: PCScreenBytesPerLine <<= 1; ! 769: } ! 770: pPCScreenDest = pScreenBitmap; // Destination PC screen ! 771: pHBLPalettes = pFrameBuffer->HBLPalettes; ! 772: } ! 773: ! 774: // Are we in a Window and medium/mix res? Need to Double Y ! 775: if ( (!bInFullScreen) && ((STRes==ST_MEDIUM_RES) || (STRes==ST_LOWMEDIUM_MIX_RES)) ) ! 776: bScrDoubleY = TRUE; ! 777: } ! 778: ! 779: //----------------------------------------------------------------------- ! 780: /* ! 781: Set details for ST screen conversion(Full-Screen version) ! 782: */ ! 783: void Screen_SetFullScreenConvertDetails(void) ! 784: { ! 785: /* FIXME */ ! 786: /* ! 787: SCREENDRAW *pScreenDraw; ! 788: ! 789: // Reset Double Y, used for Window medium res' and in full screen ! 790: bScrDoubleY = FALSE; ! 791: ! 792: if (bInFullScreen) { ! 793: // Select screen draw for standard or VDI display ! 794: if (bUseVDIRes) ! 795: pScreenDraw = &ScreenDrawVDIFullScreen[VDIRes]; ! 796: else ! 797: pScreenDraw = &ScreenDrawFullScreen[STRes]; ! 798: ! 799: // Only draw what can fit into full-screen and centre on Y ! 800: STScreenLeftSkipBytes = pScreenDraw->Overscan[OverscanMode].STScreenLeftSkipBytes; ! 801: STScreenWidthBytes = pScreenDraw->Overscan[OverscanMode].STScreenWidthBytes; ! 802: ! 803: STScreenStartHorizLine = pScreenDraw->Overscan[OverscanMode].STScreenStartHorizLine; ! 804: STScreenEndHorizLine = pScreenDraw->Overscan[OverscanMode].STScreenEndHorizLine; ! 805: ! 806: pSTScreen = pFrameBuffer->pSTScreen; // Source in ST memory ! 807: pSTScreenCopy = pFrameBuffer->pSTScreenCopy; // Previous ST screen ! 808: PCScreenBytesPerLine = Surface.lPitch; ! 809: pPCScreenDest = (unsigned char *)Surface.lpSurface; // Destination PC screen ! 810: // Get start of line on screen according to overscan(scale if double line mode) ! 811: pPCScreenDest += pScreenDraw->Overscan[OverscanMode].PCStartHorizLine ! 812: *pScreenDraw->VertPixelsPerLine*PCScreenBytesPerLine; ! 813: // And offset on X ! 814: pPCScreenDest += pScreenDraw->Overscan[OverscanMode].PCStartXOffset; ! 815: pHBLPalettes = pFrameBuffer->HBLPalettes; ! 816: ! 817: // Is non-interlaced? May need to double up on Y ! 818: if (!ConfigureParams.Screen.Advanced.bInterlacedFullScreen) ! 819: bScrDoubleY = TRUE; ! 820: } ! 821: */ ! 822: } ! 823: ! 824: //----------------------------------------------------------------------- ! 825: /* ! 826: Lock full-screen for drawing ! 827: */ ! 828: BOOL Screen_Lock(void) ! 829: { ! 830: /* FIXME */ ! 831: /* ! 832: if (bInFullScreen) { ! 833: // Get full screen DirectX details ! 834: Memory_Clear(&Surface,sizeof(DDSURFACEDESC)); ! 835: Surface.dwSize = sizeof(DDSURFACEDESC); ! 836: ! 837: // All OK? If not need to jump back to a window ! 838: if (pBackSurface->Lock(0,&Surface,DDLOCK_WAIT,0)!=DD_OK) { ! 839: Screen_ReturnFromFullScreen(); ! 840: return(FALSE); ! 841: } ! 842: // Now 'Surface.lpSurface' is valid ! 843: } ! 844: */ ! 845: return(TRUE); ! 846: } ! 847: ! 848: //----------------------------------------------------------------------- ! 849: /* ! 850: UnLock full-screen ! 851: */ ! 852: void Screen_UnLock(void) ! 853: { ! 854: // if (bInFullScreen) ! 855: //FIXME pBackSurface->Unlock(0); ! 856: } ! 857: ! 858: //----------------------------------------------------------------------- ! 859: /* ! 860: Blit our converted ST screen to window/full-screen ! 861: Note that our Window source image includes all borders so if have them disabled simply blit a smaller source rectangle! ! 862: */ ! 863: void Screen_Blit(BOOL bSwapScreen) ! 864: { ! 865: SDL_Rect rct; ! 866: rct.x=0; rct.y=0; rct.w=sdlscrn->w; rct.h=sdlscrn->h; ! 867: SDL_UpdateRects(sdlscrn, 1, &rct); ! 868: ! 869: ! 870: /* FIXME */ ! 871: /* ! 872: // Window RECT areas to Blit according to if overscan is enabled or not(source always includes all borders) ! 873: static RECT SrcWindowBitmapSizes[] = { ! 874: OVERSCAN_LEFT,OVERSCAN_BOTTOM, 320,200, // ST_LOW_RES ! 875: (OVERSCAN_LEFT<<1),(OVERSCAN_BOTTOM<<1), 640,400, // ST_MEDIUM_RES ! 876: 0,0, 640,400, // ST_HIGH_RES ! 877: (OVERSCAN_LEFT<<1),(OVERSCAN_BOTTOM<<1), 640,400, // ST_LOWMEDIUM_MIX_RES ! 878: }; ! 879: static RECT SrcWindowOverscanBitmapSizes[] = { ! 880: 0,0, OVERSCAN_LEFT+320+OVERSCAN_RIGHT,OVERSCAN_TOP+200+OVERSCAN_BOTTOM, ! 881: 0,0, (OVERSCAN_LEFT<<1)+640+(OVERSCAN_RIGHT<<1),(OVERSCAN_TOP<<1)+400+(OVERSCAN_BOTTOM<<1), ! 882: 0,0, 640,400, ! 883: 0,0, (OVERSCAN_LEFT<<1)+640+(OVERSCAN_RIGHT<<1),(OVERSCAN_TOP<<1)+400+(OVERSCAN_BOTTOM<<1), ! 884: }; ! 885: // And 1:1 scale ! 886: static RECT SrcWindowBitmapSizes_1to1[] = { ! 887: OVERSCAN_LEFT, OVERSCAN_TOP, 320, 200, ! 888: (OVERSCAN_LEFT<<1), (OVERSCAN_TOP<<1), 640, 400, ! 889: 0, 0, 640, 400, ! 890: (OVERSCAN_LEFT<<1), (OVERSCAN_TOP<<1), 640, 400, ! 891: }; ! 892: static RECT SrcWindowOverscanBitmapSizes_1to1[] = { ! 893: 0, 0, OVERSCAN_LEFT+320+OVERSCAN_RIGHT, OVERSCAN_TOP+200+OVERSCAN_BOTTOM, ! 894: 0, 0, (OVERSCAN_LEFT<<1)+640+(OVERSCAN_RIGHT<<1), (OVERSCAN_TOP<<1)+400+(OVERSCAN_BOTTOM<<1), ! 895: 0, 0, 640, 400, ! 896: 0, 0, (OVERSCAN_LEFT<<1)+640+(OVERSCAN_RIGHT<<1), (OVERSCAN_TOP<<1)+400+(OVERSCAN_BOTTOM<<1), ! 897: }; ! 898: unsigned char *pSTScreen; ! 899: RECT Rect, ViewRect, *SrcRect; ! 900: ! 901: // Blit to full screen or window? ! 902: if (bInFullScreen) { ! 903: // Swap screen, MUST use DDFLIP_WAIT(wait for complete) otherwise screen will corrupt during copy on some graphics cards... ! 904: if (bSwapScreen) ! 905: pPrimarySurface->Flip(NULL, DDFLIP_WAIT); ! 906: } ! 907: else { ! 908: // Get area of client to draw to ! 909: GetClientRect(hWnd,&Rect); ! 910: ! 911: // Find rectangle to draw to... ! 912: if (ConfigureParams.Screen.Advanced.bAllowOverscan) ! 913: ViewRect = SrcWindowOverscanBitmapSizes_1to1[STRes]; ! 914: else ! 915: ViewRect = SrcWindowBitmapSizes_1to1[STRes]; ! 916: // Find what wanted client rectangle would be for this resolution ! 917: ViewRect.right += BORDER_WIDTH; ! 918: ViewRect.bottom += BORDER_HEIGHT; ! 919: ! 920: // VDI resolution? ! 921: if (bUseVDIRes) { ! 922: // Show VDI resolution, no overscan ! 923: StretchDIBits(MainDC,SCREEN_AREA_STARTX,SCREEN_AREA_STARTY,Rect.right-BORDER_WIDTH,Rect.bottom-BORDER_HEIGHT,0,0,ScreenBMP.InfoHeader.biWidth,-ScreenBMP.InfoHeader.biHeight,pScreenBitmap,(BITMAPINFO *)&ScreenBMP.InfoHeader,DIB_RGB_COLORS,SRCCOPY); ! 924: } ! 925: else if (ConfigureParams.Screen.bUseHighRes) { ! 926: // Do as colour/mono ! 927: StretchDIBits(MainDC,SCREEN_AREA_STARTX,SCREEN_AREA_STARTY,Rect.right-BORDER_WIDTH,Rect.bottom-BORDER_HEIGHT,0,0,640,400,pScreenBitmap,(BITMAPINFO *)&ScreenBMP.InfoHeader,DIB_RGB_COLORS,SRCCOPY); ! 928: } ! 929: else { ! 930: // Does this match the client area? If so, we have a 1:1 ! 931: // Handle this differently as some graphics cards don't optimise for this case with 'SetDIBitsToDevice()' ! 932: if ( (ViewRect.right==Rect.right) && (ViewRect.bottom==Rect.bottom) ) { ! 933: HRGN ClippingRegion=NULL; ! 934: ! 935: // Find rectangle to draw to... ! 936: if (ConfigureParams.Screen.Advanced.bAllowOverscan) ! 937: SrcRect = &SrcWindowOverscanBitmapSizes_1to1[STRes]; ! 938: else { ! 939: SrcRect = &SrcWindowBitmapSizes_1to1[STRes]; ! 940: ! 941: // Generate clipping region(SetDIBitsToDevice cannot skip all edges of a bitmap) ! 942: Rect.left = SCREEN_AREA_STARTX; ! 943: Rect.top = SCREEN_AREA_STARTY; ! 944: Rect.right = SCREEN_AREA_STARTX+SrcRect->right; ! 945: Rect.bottom = SCREEN_AREA_STARTY+SrcRect->bottom; ! 946: ClippingRegion = CreateRectRgnIndirect(&Rect); ! 947: SelectClipRgn(MainDC,ClippingRegion); ! 948: } ! 949: ! 950: // Blit image ! 951: StretchDIBits(MainDC,SCREEN_AREA_STARTX-SrcRect->left,SCREEN_AREA_STARTY-SrcRect->top,ScreenBMP.InfoHeader.biWidth,-ScreenBMP.InfoHeader.biHeight,0,0,ScreenBMP.InfoHeader.biWidth,-ScreenBMP.InfoHeader.biHeight,pScreenBitmap,(BITMAPINFO *)&ScreenBMP.InfoHeader,DIB_RGB_COLORS,SRCCOPY); ! 952: ! 953: // And clean up ! 954: if (ClippingRegion) { ! 955: SelectClipRgn(MainDC,NULL); ! 956: DeleteObject(ClippingRegion); ! 957: } ! 958: } ! 959: else { ! 960: // Find rectangle to draw from... ! 961: if (ConfigureParams.Screen.Advanced.bAllowOverscan) ! 962: SrcRect = &SrcWindowOverscanBitmapSizes[STRes]; ! 963: else ! 964: SrcRect = &SrcWindowBitmapSizes[STRes]; ! 965: ! 966: // Blit(Stretch) image ! 967: StretchDIBits(MainDC,SCREEN_AREA_STARTX,SCREEN_AREA_STARTY,Rect.right-BORDER_WIDTH,Rect.bottom-BORDER_HEIGHT,SrcRect->left,SrcRect->top,SrcRect->right,SrcRect->bottom,pScreenBitmap,(BITMAPINFO *)&ScreenBMP.InfoHeader,DIB_RGB_COLORS,SRCCOPY); ! 968: } ! 969: } ! 970: } ! 971: ! 972: // Swap copy/raster buffers in screen. ! 973: pSTScreen = pFrameBuffer->pSTScreenCopy; ! 974: pFrameBuffer->pSTScreenCopy = pFrameBuffer->pSTScreen; ! 975: pFrameBuffer->pSTScreen = pSTScreen; ! 976: */ ! 977: } ! 978: ! 979: //----------------------------------------------------------------------- ! 980: /* ! 981: Swap ST Buffers, used for full-screen where have double-buffering ! 982: */ ! 983: void Screen_SwapSTBuffers(void) ! 984: { ! 985: if (bInFullScreen) { ! 986: if (pFrameBuffer==&FrameBuffers[0]) ! 987: pFrameBuffer = &FrameBuffers[1]; ! 988: else ! 989: pFrameBuffer = &FrameBuffers[0]; ! 990: } ! 991: } ! 992: ! 993: //----------------------------------------------------------------------- ! 994: /* ! 995: Get pointer to other ST frame buffer ! 996: */ ! 997: FRAMEBUFFER *Screen_GetOtherFrameBuffer(void) ! 998: { ! 999: if (pFrameBuffer==&FrameBuffers[0]) ! 1000: return(&FrameBuffers[1]); ! 1001: else ! 1002: return(&FrameBuffers[0]); ! 1003: } ! 1004: ! 1005: //----------------------------------------------------------------------- ! 1006: /* ! 1007: Draw ST screen to window/full-screen framebuffer ! 1008: */ ! 1009: void Screen_DrawFrame(BOOL bForceFlip) ! 1010: { ! 1011: void *pDrawFunction; ! 1012: ! 1013: // Scan palette/resolution masks for each line and build up palette/difference tables ! 1014: STRes = Screen_ComparePaletteMask(); ! 1015: // Do require palette? Check if changed and update ! 1016: Screen_Handle8BitPalettes(); ! 1017: // Did we change resolution this frame - allocate new screen if did so ! 1018: Screen_DidResolutionChange(); ! 1019: // Is need full-update, tag as such ! 1020: if (pFrameBuffer->bFullUpdate) ! 1021: Screen_SetFullUpdateMask(); ! 1022: ! 1023: /* Lock screen ready for drawing */ ! 1024: if (Screen_Lock()) { ! 1025: bScreenContentsChanged = FALSE; // Did change(ie needs blit?) ! 1026: if (bInFullScreen) { ! 1027: // Set details ! 1028: Screen_SetFullScreenConvertDetails(); ! 1029: // Clear screen on full update to clear out borders and also interlaced lines ! 1030: if (pFrameBuffer->bFullUpdate) ! 1031: Screen_Clear_FullScreen(); ! 1032: // Call drawing for full-screen ! 1033: if (bUseVDIRes) { ! 1034: pDrawFunction = ScreenDrawVDIFullScreen[VDIRes].pDrawFunction; ! 1035: } ! 1036: else { ! 1037: pDrawFunction = ScreenDrawFullScreen[STRes].pDrawFunction; ! 1038: //fprintf(stderr, "Screen_DrawFrame STRes=%i\n",(int)STRes); ! 1039: // Check if is Spec512 image ! 1040: if (Spec512_IsImage()) { ! 1041: // What mode were we in? Keep to 320xH or 640xH ! 1042: if (pDrawFunction==ConvertLowRes_320x16Bit) ! 1043: pDrawFunction = ConvertSpec512_320x16Bit; ! 1044: else if (pDrawFunction==ConvertLowRes_640x16Bit) ! 1045: pDrawFunction = ConvertSpec512_640x16Bit; ! 1046: } ! 1047: } ! 1048: ! 1049: if (pDrawFunction) ! 1050: CALL_VAR(pDrawFunction) ! 1051: } ! 1052: else { ! 1053: // Set details ! 1054: Screen_SetWindowConvertDetails(); ! 1055: // Call drawing for Window, ST or VDI ! 1056: if (bUseVDIRes) { ! 1057: pDrawFunction = ScreenDrawVDIWindow[VDIRes].pDrawFunction; ! 1058: } ! 1059: else { ! 1060: pDrawFunction = ScreenDrawWindow[STRes].pDrawFunction; ! 1061: // Check if is Spec512 image ! 1062: if (Spec512_IsImage()) ! 1063: pDrawFunction = ConvertSpec512_320x16Bit; ! 1064: } ! 1065: ! 1066: if (pDrawFunction) ! 1067: CALL_VAR(pDrawFunction) ! 1068: } ! 1069: ! 1070: // Unlock screen ! 1071: Screen_UnLock(); ! 1072: // Clear flags, remember type of overscan as if change need screen full update ! 1073: pFrameBuffer->bFullUpdate = FALSE; ! 1074: pFrameBuffer->OverscanModeCopy = OverscanMode; ! 1075: ! 1076: // And show to user ! 1077: if (bScreenContentsChanged || bForceFlip) { ! 1078: if (bInFullScreen) ! 1079: Screen_SwapSTBuffers(); ! 1080: Screen_Blit(TRUE); ! 1081: } ! 1082: ! 1083: /* Check for screen grabs and animation */ ! 1084: if (!bInFullScreen) { ! 1085: // Grab screen shots ! 1086: ScreenSnapShot_CheckPrintKey(); ! 1087: // Grab any animation ! 1088: ScreenSnapShot_RecordFrame(bScreenContentsChanged); ! 1089: } ! 1090: } ! 1091: } ! 1092: ! 1093: //----------------------------------------------------------------------- ! 1094: /* ! 1095: Draw ST screen to window/full-screen ! 1096: */ ! 1097: void Screen_Draw(void) ! 1098: { ! 1099: // RECT Rect; ! 1100: // HBRUSH WhiteBrush; ! 1101: BOOL bDrawFrame = FALSE; ! 1102: ! 1103: /* Are we holding screen? Ie let user choose options while in full-screen mode using GDI */ ! 1104: if (bInFullScreen && bFullScreenHold) { ! 1105: // Just update status bar ! 1106: StatusBar_UpdateIcons(); ! 1107: return; ! 1108: } ! 1109: ! 1110: // Free any GDI stored surfaces, as not needed now ! 1111: /* DSurface_FreeGDIScreen();*/ ! 1112: ! 1113: if (!bQuitProgram) { ! 1114: /* Wait for next display(at 50fps), is ignored if running max speed */ ! 1115: /* FIXME */ ! 1116: #if 0 ! 1117: if ( !(ConfigureParams.Screen.Advanced.bSyncToRetrace && bInFullScreen) ) { ! 1118: // If in Max speed mode, just get on with it, or else wait for VBL timer ! 1119: if (ConfigureParams.Configure.nMinMaxSpeed!=MINMAXSPEED_MAX) { ! 1120: /* Has VBL already occured? Means we can't keep 50fps to warn user */ ! 1121: if (Main_AlreadyWaitingVBLEvent()) { ! 1122: /* Increase counter for number of consecutive dropped frames */ ! 1123: nDroppedFrames++; ! 1124: /* If emulation has gone slow for 1/2 second or more, inform user */ ! 1125: if (nDroppedFrames>=25) ! 1126: StatusBar_SetIcon(STATUS_ICON_FRAMERATE,ICONSTATE_UPDATE); ! 1127: } ! 1128: else ! 1129: nDroppedFrames = 0; ! 1130: /* Wait for VBL event */ ! 1131: Main_WaitVBLEvent(); ! 1132: } ! 1133: } ! 1134: ! 1135: /* And create ST screen, AT LEAST 1/50th second must have passed otherwise don't draw */ ! 1136: if (ConfigureParams.Screen.Advanced.bSyncToRetrace && bInFullScreen) ! 1137: { ! 1138: if (VideoBase) ! 1139: bDrawFrame = TRUE; ! 1140: } ! 1141: else ! 1142: #endif ! 1143: //fprintf(stderr, "Screen_Draw: VBLCounter=%i VideoBase=%i\n", VBLCounter, VideoBase); ! 1144: { ! 1145: if ( /*((VBLCounter-OldVBLCounter)>0) && */ VideoBase ) ! 1146: bDrawFrame = TRUE; ! 1147: } ! 1148: ! 1149: // Need to hold display for a while? Allows VDI resolutions to bypass start-up screens which don't use VDI ! 1150: if (bHoldScreenDisplay && bUseVDIRes) ! 1151: bDrawFrame = FALSE; ! 1152: ! 1153: if ( bDrawFrame ) { ! 1154: OldVBLCounter = VBLCounter; /* Store counter so only enter here 50 times a second MAXIMUM */ ! 1155: ! 1156: /* And draw(if screen contents changed) */ ! 1157: Screen_DrawFrame(FALSE); ! 1158: ! 1159: /* And status bar */ ! 1160: StatusBar_UpdateIcons(); ! 1161: } ! 1162: else { ! 1163: /* Blank Window with ST-white(0x777) rectangle if holding display */ ! 1164: if (!bInFullScreen && bHoldScreenDisplay && bUseVDIRes) { ! 1165: /*FIXME*/ /*GetClientRect(hWnd,&Rect); ! 1166: Rect.left = SCREEN_AREA_STARTX; ! 1167: Rect.top = SCREEN_AREA_STARTY; ! 1168: Rect.right -= BORDER_WIDTH; ! 1169: Rect.bottom -= BORDER_HEIGHT-SCREEN_AREA_STARTY; ! 1170: // Mono or colour? Choose ST 0x777 or full white ! 1171: if (VDIRes==2) ! 1172: WhiteBrush = CreateSolidBrush(RGB(255,255,255)); ! 1173: else ! 1174: WhiteBrush = CreateSolidBrush(RGB(0x7<<5,0x7<<5,0x7<<5)); ! 1175: FillRect(MainDC,&Rect,WhiteBrush); ! 1176: DeleteObject(WhiteBrush);*/ ! 1177: } ! 1178: } ! 1179: ! 1180: // Check printer status ! 1181: Printer_CheckIdleStatus(); ! 1182: } ! 1183: ! 1184: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.