![[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 [Tom Morton FrontierVM] / frontvm / hardware|
Return to screen.c CVS log | Up to [Tom Morton FrontierVM] / frontvm / hardware |
1.1 root 1: /*
2: Hatari - screen.c
3:
4: This file is distributed under the GNU Public License, version 2 or at your
5: option any later version. Read the file gpl.txt for details.
6:
7: This code converts a 1/2/4 plane ST format screen to either 8 or 16-bit PC
8: format. An awful lost of processing is needed to do this conversion - we
9: cannot simply change palettes on interrupts as it is possible with DOS.
10: The main code processes the palette/resolution mask tables to find exactly
11: which lines need to updating and the conversion routines themselves only
12: update 16-pixel blocks which differ from the previous frame - this gives a
13: large performance increase.
14: Each conversion routine can convert any part of the source ST screen (which
15: includes the overscan border, usually set to colour zero) so they can be used
16: for both window and full-screen mode.
17: Note that in Hi-Resolution we have no overscan and just two colors so we can
18: optimise things further. Also when running in maximum speed we make sure we
19: only convert the screen every 50 times a second - inbetween frames are not
20: processed.
21: */
22:
23: #include <SDL.h>
24:
25: #include "main.h"
26: #include "configuration.h"
27: #include "m68000.h"
28: #include "memAlloc.h"
29: #include "misc.h"
30: #include "screen.h"
31: #include "screenConvert.h"
32: #include "video.h"
33: #include "scalebit.h"
34:
35: int len_main_palette;
36: unsigned short MainPalette[256];
37: unsigned short CtrlPalette[16];
38:
39: SCREENDRAW ScreenDraw; /* Set up with details of drawing functions */
40: unsigned char *pScreenBitmap=NULL; /* Screen pixels in PC RGB format, allocated with 'CreateDIBSection' */
41: unsigned char *pPCScreenDest; /* Destination PC buffer */
42: int STScreenStartHorizLine,STScreenEndHorizLine; /* Start/End lines to be converted */
43: int PCScreenBytesPerLine, STScreenWidthBytes, STScreenLeftSkipBytes;
44: BOOL bInFullScreen=FALSE; /* TRUE if in full screen */
45: BOOL bFullScreenHold = FALSE; /* TRUE if hold display while full screen */
46: BOOL bScreenContentsChanged; /* TRUE if buffer changed and requires blitting */
47: BOOL bTooSlowSoSkipAFlip = FALSE;
48: int nDroppedFrames=0; /* Number of dropped frames during emulation run */
49: int prevChosenDisplayMode = -1;
50:
51: int STScreenLineOffset[SCREEN_HEIGHT_HBL]; /* Offsets for ST screen lines eg, 0,160,320... */
52: unsigned long MainRGBPalette[256];
53: unsigned long CtrlRGBPalette[16];
54:
55: SDL_Surface *sdlscrn; /* The SDL screen surface */
56: BOOL bGrabMouse = FALSE; /* Grab the mouse cursor in the window */
57:
58:
59: /*-----------------------------------------------------------------------*/
60: /*
61: Set window size
62: */
63: void Screen_SetWindowRes()
64: {
65: prevChosenDisplayMode = ConfigureParams.Screen.ChosenDisplayMode;
66: switch (ConfigureParams.Screen.ChosenDisplayMode) {
67: case DISPLAYMODE_HICOL_1X:
68: sdlscrn=SDL_SetVideoMode(320, 200, 16, SDL_DOUBLEBUF | SDL_ANYFORMAT);
69: break;
70: default:
71: sdlscrn=SDL_SetVideoMode(640, 400, 16, SDL_DOUBLEBUF | SDL_ANYFORMAT);
72: break;
73: }
74: if ((sdlscrn == NULL) || (sdlscrn->format->BytesPerPixel < 2))
75: {
76: fprintf(stderr, "Could not set video mode:\n %s\n", SDL_GetError() );
77: SDL_Quit();
78: exit(-2);
79: }
80: pScreenBitmap=sdlscrn->pixels;
81:
82: if(!bGrabMouse)
83: {
84: SDL_WM_GrabInput(SDL_GRAB_OFF); /* Un-grab mouse pointer in windowed mode */
85: }
86: Screen_SetDrawModes(); /* Set draw modes(store which modes to use!) */
87: }
88:
89: /*-----------------------------------------------------------------------*/
90: /*
91: Init Screen bitmap and buffers/tables needed for ST to PC screen conversion
92: */
93: void Screen_Init(void)
94: {
95: Screen_SetWindowRes();
96:
97: Screen_SetScreenLineOffsets(); /* Store offset to each horizontal line */
98:
99: /* Configure some SDL stuff: */
100: SDL_WM_SetCaption(PROG_NAME, "Frontier");
101: SDL_EventState(SDL_MOUSEMOTION, SDL_ENABLE);
102: SDL_EventState(SDL_MOUSEBUTTONDOWN, SDL_ENABLE);
103: SDL_EventState(SDL_MOUSEBUTTONUP, SDL_ENABLE);
104: SDL_ShowCursor(SDL_DISABLE);
105: }
106:
107:
108: /*-----------------------------------------------------------------------*/
109: /*
110: Free screen bitmap and allocated resources
111: */
112: void Screen_UnInit(void)
113: {
114: }
115:
116:
117: /*-----------------------------------------------------------------------*/
118: /*
119: Reset screen
120: */
121: void Screen_Reset(void)
122: {
123: }
124:
125: /*-----------------------------------------------------------------------*/
126: /*
127: Store Y offset for each horizontal line in our source ST screen for each reference in assembler(no multiply)
128: */
129: void Screen_SetScreenLineOffsets(void)
130: {
131: int i;
132:
133: for(i=0; i<SCREEN_HEIGHT_HBL; i++)
134: STScreenLineOffset[i] = i * SCREENBYTES_LINE;
135: }
136:
137:
138: /*-----------------------------------------------------------------------*/
139:
140: /*-----------------------------------------------------------------------*/
141: /*
142: Enter Full screen mode
143: */
144:
145: static SDL_Surface *set_new_sdl_fsmode() {
146: SDL_Surface *newsdlscrn;
147:
148: newsdlscrn = SDL_SetVideoMode(sdlscrn->w, sdlscrn->h,
149: ScreenDraw.BitDepth, SDL_DOUBLEBUF | SDL_ANYFORMAT | SDL_FULLSCREEN);
150: return newsdlscrn;
151: }
152:
153: void Screen_EnterFullScreen(void)
154: {
155: SDL_Surface *newsdlscrn;
156:
157: if (!bInFullScreen)
158: {
159: Main_PauseEmulation(); /* Hold things... */
160: SDL_Delay(20); /* To give sound time to clear! */
161:
162: newsdlscrn = set_new_sdl_fsmode();
163: Screen_SetDrawModes(); /* Set draw modes(store which modes to use!) */
164:
165: if( newsdlscrn==NULL )
166: {
167: fprintf(stderr, "Could not set video mode:\n %s\n", SDL_GetError() );
168: }
169: else
170: {
171: sdlscrn = newsdlscrn;
172: pScreenBitmap = newsdlscrn->pixels;
173: bInFullScreen = TRUE;
174:
175: Screen_ClearScreen(); /* Black out screen bitmap as will be invalid when return */
176: }
177: Main_UnPauseEmulation(); /* And off we go... */
178:
179: SDL_WM_GrabInput(SDL_GRAB_ON); /* Grab mouse pointer in fullscreen */
180: }
181: }
182:
183:
184: /*-----------------------------------------------------------------------*/
185: /*
186: Return from Full screen mode back to a window
187: */
188: void Screen_ReturnFromFullScreen(void)
189: {
190: if (bInFullScreen)
191: {
192: Main_PauseEmulation(); /* Hold things... */
193: SDL_Delay(20); /* To give sound time to clear! */
194:
195: bInFullScreen = FALSE;
196:
197: Screen_SetWindowRes();
198: Screen_SetDrawModes();
199:
200: Main_UnPauseEmulation(); /* And off we go... */
201: }
202: }
203:
204:
205: /*-----------------------------------------------------------------------*/
206: /*
207: Clear Window display memory
208: */
209: void Screen_ClearScreen(void)
210: {
211: SDL_FillRect(sdlscrn,NULL, SDL_MapRGB(sdlscrn->format, 0, 0, 0) );
212: }
213:
214: /*-----------------------------------------------------------------------*/
215: /*
216: */
217: void Screen_SetDrawModes(void)
218: {
219: /* Clear out */
220: Memory_Clear(&ScreenDraw,sizeof(SCREENDRAW));
221:
222: ScreenDraw.pDrawFunction = screendrawfuncs[sdlscrn->format->BytesPerPixel][ConfigureParams.Screen.ChosenDisplayMode];
223: /* Assign full-screen draw modes from chosen option under dialog */
224: switch (ConfigureParams.Screen.ChosenDisplayMode) {
225:
226: case DISPLAYMODE_HICOL_1X:
227: ScreenDraw.Width = 320;
228: ScreenDraw.Height = 200;
229: ScreenDraw.BitDepth = sdlscrn->format->BitsPerPixel;
230: ScreenDraw.VertPixelsPerLine = 1;
231: ScreenDraw.PCStartHorizLine = 0;
232: ScreenDraw.MouseScale = 1;
233: break;
234: case DISPLAYMODE_HICOL_2X:
235: default:
236: ScreenDraw.Width = 640;
237: ScreenDraw.Height = 480;
238: ScreenDraw.BitDepth = sdlscrn->format->BitsPerPixel;
239: ScreenDraw.VertPixelsPerLine = 2;
240: ScreenDraw.PCStartHorizLine = 0;
241: ScreenDraw.MouseScale = 2;
242: break;
243: }
244: }
245:
246:
247: /*-----------------------------------------------------------------------*/
248: /*
249: Set details for ST screen conversion(Window version)
250: */
251: void Screen_SetWindowConvertDetails(void)
252: {
253: pPCScreenDest = pScreenBitmap; /* Destination PC screen */
254:
255: STScreenStartHorizLine = 0; /* Full height */
256:
257: /* Always draw to WHOLE screen including ALL borders */
258: STScreenLeftSkipBytes = 0; /* Number of bytes to skip on ST screen for left(border) */
259: STScreenWidthBytes = SCREENBYTES_LINE; /* Number of horizontal bytes in our ST screen */
260:
261: STScreenEndHorizLine = SCREEN_HEIGHT_HBL;
262:
263: PCScreenBytesPerLine = sdlscrn->pitch;
264: }
265:
266: /*-----------------------------------------------------------------------*/
267: /*
268: Set details for ST screen conversion (Full-Screen version)
269: */
270: void Screen_SetFullScreenConvertDetails(void)
271: {
272: /* Only draw what can fit into full-screen and centre on Y */
273: STScreenLeftSkipBytes = 0;
274: STScreenWidthBytes = SCREENBYTES_LINE;
275:
276: STScreenStartHorizLine = 0;
277: STScreenEndHorizLine = SCREEN_HEIGHT_HBL;
278:
279: PCScreenBytesPerLine = sdlscrn->pitch;
280: pPCScreenDest = (unsigned char *)sdlscrn->pixels; /* Destination PC screen */
281: /* And offset on X */
282: // pPCScreenDest += ScreenDraw.PCStartXOffset;
283: //pPCScreenDest += ScreenDraw.PCStartHorizLine * PCScreenBytesPerLine;
284:
285: /* Is non-interlaced? May need to double up on Y */
286: bScrDoubleY = TRUE;
287: }
288:
289:
290: /*-----------------------------------------------------------------------*/
291: /*
292: Lock full-screen for drawing
293: */
294: BOOL Screen_Lock(void)
295: {
296: if(SDL_MUSTLOCK(sdlscrn))
297: {
298: if(SDL_LockSurface(sdlscrn))
299: {
300: Screen_ReturnFromFullScreen(); /* All OK? If not need to jump back to a window */
301: return(FALSE);
302: }
303: }
304:
305: return(TRUE);
306: }
307:
308: /*-----------------------------------------------------------------------*/
309: /*
310: UnLock full-screen
311: */
312: void Screen_UnLock(void)
313: {
314: if( SDL_MUSTLOCK(sdlscrn) )
315: SDL_UnlockSurface(sdlscrn);
316: }
317:
318:
319: /*-----------------------------------------------------------------------*/
320: /*
321: Draw ST screen to window/full-screen framebuffer
322: */
323: void Screen_DrawFrame(BOOL bForceFlip)
324: {
325: void *pDrawFunction;
326:
327: if ((!ConfigureParams.Screen.bFullScreen) &&
328: (prevChosenDisplayMode != ConfigureParams.Screen.ChosenDisplayMode))
329: Screen_SetWindowRes ();
330:
331: //if (!bScreenContentsChanged) return;
332: if (bTooSlowSoSkipAFlip) {
333: bTooSlowSoSkipAFlip = FALSE;
334: return;
335: }
336:
337: /* Lock screen ready for drawing */
338: if (Screen_Lock()) {
339: bScreenContentsChanged = FALSE;
340: /* Set details */
341: if (bInFullScreen)
342: Screen_SetFullScreenConvertDetails();
343: else
344: Screen_SetWindowConvertDetails();
345: /* Call drawing for full-screen */
346: pDrawFunction = ScreenDraw.pDrawFunction;
347:
348: /* build RGB palettes */
349: BuildRGBPalette (MainRGBPalette, MainPalette, len_main_palette);
350: BuildRGBPalette (CtrlRGBPalette, CtrlPalette, 16);
351:
352: if (pDrawFunction)
353: CALL_VAR(pDrawFunction)
354:
355: /* Unlock screen */
356: Screen_UnLock();
357:
358: SDL_Flip(sdlscrn);
359: }
360: }
361:
362: /*-----------------------------------------------------------------------*/
363: /*
364: Draw ST screen to window/full-screen
365: This is now called from the 68k program's vblank handler,
366: since we need the vblank to update palettes appropriately
367: before drawing the screen (for frontier)
368: */
369: void Screen_Draw(unsigned long _dummy)
370: {
371: /* Are we holding screen? Ie let user choose options while in full-screen mode using GDI */
372: if (bInFullScreen && bFullScreenHold)
373: {
374: return;
375: }
376:
377: if (!bQuitProgram)
378: {
379: if(VideoBase)
380: {
381: Screen_DrawFrame(FALSE);
382: }
383: }
384:
385: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.