![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to video.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 video.c CVS log | Up to [HATARI the Atari ST Emulator] / hatari / src |
1.1 root 1: /*
2: Hatari
3:
4: Video hardware handling. This code handling all to do with the video chip. So, we handle
5: VBLs, HBLs, copying the ST screen to a buffer to simulate the TV raster trace, border
6: removal, palette changes per HBL, the 'video address pointer' etc...
7: */
8:
9: //#include <SDL.h>
10:
11: #include "main.h"
12: #include "debug.h"
13: #include "decode.h"
14: #include "dialog.h"
15: #include "fdc.h"
16: #include "int.h"
17: #include "ikbd.h"
18: #include "m68000.h"
19: #include "memAlloc.h"
20: #include "memorySnapShot.h"
21: #include "mfp.h"
22: #include "screen.h"
23: #include "shortcut.h"
24: #include "sound.h"
25: #include "spec512.h"
26: #include "stMemory.h"
27: #include "vdi.h"
28: #include "video.h"
29: #include "ymFormat.h"
30: #include "syncTables.h" /* Clock-cycle tables */
31:
32: long VideoAddress; /* Address of video display in ST screen space */
33: unsigned char VideoSyncByte,VideoShifterByte; /* VideoSync (0xff820a) and VideoShifter(0xff8260) values store in video chip */
34: BOOL bUseHighRes = TRUE; /* Use hi-res (ie Mono monitor) */
35: int nVBLs, nHBL; /* VBL Counter, HBL line */
36: int nStartHBL,nEndHBL; /* Start/End HBL for visible screen(64 lines in Top border) */
37: int OverscanMode; /* OVERSCANMODE_xxxx for current display frame */
38: unsigned short int HBLPalettes[(NUM_VISIBLE_LINES+1)*16]; /* 1x16 colour palette per screen line, +1 line just incase write after line 200 */
39: unsigned long HBLPaletteMasks[NUM_VISIBLE_LINES+1]; /* Bit mask of palette colours changes, top bit set is resolution change */
40: unsigned short int *pHBLPalettes; /* Pointer to current palette lists, one per HBL */
41: unsigned long *pHBLPaletteMasks;
42: unsigned long VideoBase; /* Base address in ST Ram for screen(read on each VBL) */
43: unsigned long VideoRaster; /* Pointer to Video raster, after VideoBase in PC address space. Use to copy data on HBL */
44: int SyncHandler_Value; /* Value to pass to 'Video_SyncHandler_xxxx' functions */
45: int LeftRightBorder; /* BORDERMASK_xxxx used to simulate left/right border removal */
46:
47:
48: /*-----------------------------------------------------------------------*/
49: /*
50: Reset video chip
51: */
52: void Video_Reset(void)
53: {
54: /* NOTE! Must reset all of these register type things here!!!! */
55: VideoSyncByte = 0;
56: /* Are we in high-res? */
57: if (bUseHighRes)
58: VideoShifterByte = ST_HIGH_RES; /* Boot up for mono monitor */
59: else
60: VideoShifterByte = ST_LOW_RES;
61:
62: /* Reset VBL counter */
63: nVBLs = 0;
64: /* Reset addresses */
65: VideoBase = 0L;
66: /* Clear ready for new VBL */
67: Video_ClearOnVBL();
68: }
69:
70: /*-----------------------------------------------------------------------*/
71: /*
72: Save/Restore snapshot of local variables('MemorySnapShot_Store' handles type)
73: */
74: void Video_MemorySnapShot_Capture(BOOL bSave)
75: {
76: /* Save/Restore details */
77: MemorySnapShot_Store(&VideoAddress,sizeof(VideoAddress));
78: MemorySnapShot_Store(&VideoSyncByte,sizeof(VideoSyncByte));
79: MemorySnapShot_Store(&VideoShifterByte,sizeof(VideoShifterByte));
80: MemorySnapShot_Store(&bUseHighRes,sizeof(bUseHighRes));
81: MemorySnapShot_Store(&nVBLs,sizeof(nVBLs));
82: MemorySnapShot_Store(&nHBL,sizeof(nHBL));
83: MemorySnapShot_Store(&nStartHBL,sizeof(nStartHBL));
84: MemorySnapShot_Store(&nEndHBL,sizeof(nEndHBL));
85: MemorySnapShot_Store(&OverscanMode,sizeof(OverscanMode));
86: MemorySnapShot_Store(HBLPalettes,sizeof(HBLPalettes));
87: MemorySnapShot_Store(HBLPaletteMasks,sizeof(HBLPaletteMasks));
88: MemorySnapShot_Store(&VideoBase,sizeof(VideoBase));
89: MemorySnapShot_Store(&VideoRaster,sizeof(VideoRaster));
90: }
91:
92: /*-----------------------------------------------------------------------*/
93: /*
94: Called on VBL, set registers ready for frame
95: */
96: void Video_ClearOnVBL(void)
97: {
98: /* New screen, so first HBL */
99: nHBL = 0;
100: nStartHBL = SCREEN_START_HBL;
101: nEndHBL = SCREEN_START_HBL+SCREEN_HEIGHT_HBL;
102: OverscanMode = OVERSCANMODE_NONE;
103:
104: /* Get screen address pointer, align to 256 bytes(ie ignore lowest byte) */
105: VideoBase = (unsigned long)STMemory_ReadByte(0xff8201)<<16 | (unsigned long)STMemory_ReadByte(0xff8203)<<8;
106: VideoRaster = (unsigned long)STRam+VideoBase;
107: pSTScreen = pFrameBuffer->pSTScreen;
108:
109: Video_StartHBL();
110: Video_SetScreenRasters();
111: Spec512_StartVBL();
112: }
113:
114: /*-----------------------------------------------------------------------*/
115: /*
116: Calculate Video address pointer and store in 'VideoAddress'
117: */
118: void Video_CalculateAddress(void)
119: {
120: int X,Y,FrameCycles,nPixelsIn;
121:
122: /* Find number of cycles passed during frame */
123: FrameCycles = Int_FindFrameCycles();
124:
125: /* Top of screen is usually 64 lines from VBL(64x512=32768 cycles) */
126: if (FrameCycles<(nStartHBL*CYCLES_PER_LINE))
127: VideoAddress = 0;
128: else {
129: /* Now find which pixel we are on(ignore left/right borders) */
130: /* 96 + 320 + 96 = 512 pixels per scan line(each pixel is one cycle) */
131: nPixelsIn = FrameCycles-(nStartHBL*CYCLES_PER_LINE);
132: /* Convert this to an X,Y pixel on screen */
133: Y = nPixelsIn/512;
134: X = nPixelsIn - (Y*512);
135: if (X<SCREEN_START_CYCLE) /* Limit if in NULL area outside screen */
136: X = SCREEN_START_CYCLE;
137: if (X>(512-SCREEN_START_CYCLE))
138: X = (512-SCREEN_START_CYCLE);
139: /* X is now from 96 to 416(320 pixels), subtract 96 to give X pixel across screen! */
140: X = ((X-SCREEN_START_CYCLE)>>1)&(~1);
141:
142: if (Y<(nEndHBL-nStartHBL)) /* Limit to end of screen */
143: VideoAddress = (Y*160) + X;
144: else
145: VideoAddress = ((nEndHBL-nStartHBL)*160);
146: }
147:
148: /* Offset from start of screen(MUST use address loading into video display) */
149: VideoAddress += VideoBase;
150: }
151:
152: /*-----------------------------------------------------------------------*/
153: /*
154: Read Video address pointer(from current cycle count), and return 24-bit address in 'ebx'
155: */
156: unsigned long Video_ReadAddress(void)
157: {
158: Video_CalculateAddress(); /* Find address from current cycle count into display frame */
159: return( VideoAddress );
160: }
161:
162: /*-----------------------------------------------------------------------*/
163: /*
164: VBL interrupt, draw screen and reset counters
165: */
166: void Video_InterruptHandler_VBL(void)
167: {
168: int PendingCyclesOver;
169:
170: /* Store cycles we went over for this frame(this is our inital count) */
171: PendingCyclesOver = -PendingInterruptCount; /* +ve */
172:
173: /* Remove this interrupt from list and re-order */
174: Int_AcknowledgeInterrupt();
175: /* Start HBL interrupts(313 per frame) - MUST do before add in cycles */
176: Int_AddAbsoluteInterrupt(CYCLES_ENDLINE,INTERRUPT_VIDEO_ENDLINE);
177: Int_AddAbsoluteInterrupt(CYCLES_HBL,INTERRUPT_VIDEO_HBL);
178: Int_AddAbsoluteInterrupt(CYCLES_PER_FRAME,INTERRUPT_VIDEO_VBL);
179:
180: /* Set frame cycles, used for Video Address */
181: nFrameCyclesOver = PendingCyclesOver; /* Number of cycles into frame */
182:
183: /* Clear any key presses which are due to be de-bounced(held for one ST frame) */
184: //FIXME View_DebounceAllKeys();
185: /* Check 'Function' keys, so if press F12 we update screen correctly to Window! */
186: ShortCut_CheckKeys();
187: /* See if need to save/restore emulation state during this 'safe-zone' */
188: MemorySnapShot_CheckSaveRestore();
189: /* Use extended VDI resolution? If so, just copy whole screen on VBL rather than per HBL */
190: if (bUseVDIRes)
191: Video_CopyVDIScreen();
192: /* Draw screen, skip frame if need to */
193: if (ConfigureParams.Screen.Advanced.bFrameSkip) {
194: if (nVBLs&1)
195: Screen_Draw();
196: }
197: else
198: Screen_Draw();
199: /* Update counter for number of screen refreshes per second(for debugging) */
200: nVBLs++;
201: /* Set video registers for frame */
202: Video_ClearOnVBL();
203: /* Store off PSG registers for YM file, is enabled */
204: YMFormat_UpdateRecording();
205: /* Generate 1/50th second of sound sample data, to be played by DirectSound thread */
206: Sound_Update_VBL();
207:
208: if (4>FIND_IPL) { /* Vertical blank, level 4! */
209: ADD_CYCLES(44+4,5,3); /* Interrupt */
210: ExceptionVector = EXCEPTION_VBLANK;
211: M68000_Exception(); /* VBL interrupt */
212: }
213: else {
214: /* Higher priority interrupt is currently being executed(eg MFP). Set VBL to occur later */
215: if (!Int_InterruptActive(INTERRUPT_VIDEO_VBL_PENDING))
216: Int_AddAbsoluteInterrupt(100,INTERRUPT_VIDEO_VBL_PENDING);
217: }
218:
219: /* Is this a good place to send the keyboard packets? Done once per frame */
220: /* And handle any windows messages, check for quit message */
221: Main_EventHandler(); /* Process messages, set 'bQuitProgram' if user tries to quit */
222: IKBD_SendAutoKeyboardCommands(); /* On each VBL send automatic keyboard packets for mouse, joysticks etc... */
223: if(bQuitProgram)
224: Int_AddAbsoluteInterrupt(4, 0L); /* Pass NULL interrupt function to quit cleanly */
225:
226: }
227:
228:
229: /*-----------------------------------------------------------------------*/
230: /*
231: This doesn't make sense... I always thought if a 68000 interrupt, eg the VBL, occurs while a
232: higher priority interrupt was in service the interrupt was ignored. This does not seem to be
233: the case. This really needs checking on a real ST, but I have noticed some menu discs run
234: sound routines from the MFP timers which overlap the VBL, yet the VBL still occurs...
235: */
236: void Video_InterruptHandler_VBL_Pending(void)
237: {
238: /* Remove this interrupt from list and re-order */
239: Int_AcknowledgeInterrupt();
240:
241: /* Check if can execute VBL */
242: if (4>FIND_IPL) { /* Vertical blank, level 4! */
243: ADD_CYCLES(44+4,5,3); /* Interrupt */
244: ExceptionVector = EXCEPTION_VBLANK;
245: M68000_Exception(); /* VBL interrupt */
246: }
247: else
248: Int_AddAbsoluteInterrupt(100,INTERRUPT_VIDEO_VBL_PENDING);
249: }
250:
251:
252: /*-----------------------------------------------------------------------*/
253: /*
254: End Of Line interrupt
255: As this occurs at the end of a line we cannot get timing for START of first line(as in Spectrum 512)
256: */
257: void Video_InterruptHandler_EndLine(void)
258: {
259: /* Remove this interrupt from list and re-order */
260: Int_AcknowledgeInterrupt();
261: /* Generate new HBL, if need to - there are 313 HBLs per frame */
262: if (nHBL<(SCANLINES_PER_FRAME-1))
263: Int_AddAbsoluteInterrupt(CYCLES_PER_LINE,INTERRUPT_VIDEO_ENDLINE);
264:
265: /* Timer A/B occur at END of first visible screen line in Event Count mode */
266: if ( (nHBL>=nStartHBL) && (nHBL<nEndHBL) )
267: {
268: /* Handle Timers A and B when using Event Count mode(timer taken from HBL) */
269: if (MFP_TACR==0x08) // Is timer in Event Count mode?
270: MFP_TimerA_EventCount_Interrupt();
271: if (MFP_TBCR==0x08) // Is timer in Event Count mode?
272: MFP_TimerB_EventCount_Interrupt();
273: }
274:
275: FDC_UpdateHBL(); // Update FDC motion
276: Video_EndHBL(); // Increase HBL count, copy line to display buffer and do any video trickery
277:
278: /* If we don't often pump data into the event queue, the SDL misses events... grr... */
279: if( !(nHBL&63) )
280: {
281: Main_EventHandler();
282: /*IKBD_SendAutoKeyboardCommands();*/
283: }
284: }
285:
286:
287: //-----------------------------------------------------------------------
288: /*
289: HBL interrupt - this is very inaccurate on ST and appears to occur around 1/3rd way into
290: the display!
291: */
292: void Video_InterruptHandler_HBL(void)
293: {
294: // Remove this interrupt from list and re-order
295: Int_AcknowledgeInterrupt();
296: // Generate new Timer AB, if need to - there are 313 HBLs per frame
297: if (nHBL<(SCANLINES_PER_FRAME-1))
298: Int_AddAbsoluteInterrupt(CYCLES_PER_LINE,INTERRUPT_VIDEO_HBL);
299:
300: if (2>FIND_IPL) { // Horizontal blank, level 2!
301: ADD_CYCLES(44+4,5,3); // Interrupt
302: ExceptionVector = EXCEPTION_HBLANK;
303: M68000_Exception(); // HBL interrupt
304: }
305: }
306:
307:
308: //-----------------------------------------------------------------------
309: /*
310: Sync Table handlers
311: */
312: void Video_SyncHandler_SetLeftRightBorder(void)
313: {
314: LeftRightBorder |= SyncHandler_Value; // Turn on left/right borders
315: }
316:
317: void Video_SyncHandler_SetSyncScrollOffset(void)
318: {
319: VideoRaster += SyncHandler_Value; // Add offset to video address(sync-scroll)
320: }
321:
322: void Video_SyncHandler_SetTopBorder(void)
323: {
324: OverscanMode |= OVERSCANMODE_TOP; // Set overscan bit
325: nStartHBL = FIRST_VISIBLE_HBL; // New start screen line
326: }
327:
328: void Video_SyncHandler_SetBottomBorder(void)
329: {
330: OverscanMode |= OVERSCANMODE_BOTTOM; // Set overscan bit
331: nEndHBL = SCREEN_START_HBL+SCREEN_HEIGHT_HBL+OVERSCAN_BOTTOM; // New end screen line
332: }
333:
334: //-----------------------------------------------------------------------
335: /*
336: Write to VideoShifter(0xff8260), resolution bits
337: */
338: void Video_WriteToShifter(void)
339: {
340: // Store into table so can test at end of HBL
341: Video_StoreSyncShifterAccess(0xff8260,VideoShifterByte);
342: }
343:
344: //-----------------------------------------------------------------------
345: /*
346: Write to VideoSync(0xff820a), Hz setting
347: */
348: void Video_WriteToSync(void)
349: {
350: // Store into table so can test at end of HBL
351: Video_StoreSyncShifterAccess(0xff820a,VideoSyncByte);
352: }
353:
354: //-----------------------------------------------------------------------
355: /*
356: Check access Video(0xff8260 or 0xff820a) to see if opened top/bottom/left/right borders or
357: even tried for a SyncScroll
358: */
359: BOOL Video_CheckSyncShifterTable(unsigned int Address, unsigned char Byte, int FrameCycles, SYNCSHIFTER_ACCESS_TABLE *pAccessTable)
360: {
361: SYNCSHIFTER_ACCESS *pSyncShifter;
362: BOOL bFoundMatch=FALSE;
363: int i=0;
364:
365: // Scan each shifter entry to see if this new values matches - if not rest
366: while(pAccessTable[i].nChecks) {
367: // Get table of entries, index at 'counter'
368: pSyncShifter = &pAccessTable[i].pSyncShifterAccess[pAccessTable[i].nCount];
369: // Does next value match table?
370: if ( (pSyncShifter->Address==Address) && (pSyncShifter->Byte==Byte) && (pSyncShifter->FrameCycles==FrameCycles) ) {
371: // Set flag(used for debugging)
372: bFoundMatch = TRUE;
373:
374: // Got match increase count
375: pAccessTable[i].nCount++;
376: // Is table complete?
377: if (pAccessTable[i].nCount==pAccessTable[i].nChecks) {
378: // Reset count, ready for next time
379: pAccessTable[i].nCount = 0;
380: // Yes, call handler function with passed variable
381: SyncHandler_Value = pAccessTable[i].Value;
382: CALL_VAR(pAccessTable[i].pFunc);
383: }
384: }
385: else {
386: // No match, reset table count
387: pAccessTable[i].nCount = 0;
388: }
389:
390: i++;
391: }
392:
393: return(bFoundMatch);
394: }
395:
396: //-----------------------------------------------------------------------
397: /*
398: Store Sync/Shifter write into table so can check at end of HBL for border/sync-scroll hardware tricks
399: */
400: void Video_StoreSyncShifterAccess(unsigned int Address,unsigned char Byte)
401: {
402: int FrameCycles = Int_FindFrameCycles();
403:
404: // Get back to where instruction started for timing
405: FrameCycles -= M68000_FindLastInstructionCycles();
406:
407: // char szString[256];
408: // sprintf(szString,"0x%X=0x%2.2X %d(%d) @ %d",Address,Byte,FrameCycles,FrameCycles&511,nHBL);
409: // debug << szString << endl;
410:
411: Video_CheckSyncShifterTable(Address,Byte,FrameCycles, pTopBorderAccessTable);
412: Video_CheckSyncShifterTable(Address,Byte,FrameCycles, pBottomBorderAccessTable);
413: Video_CheckSyncShifterTable(Address,Byte,FrameCycles&511, pLeftRightBorderAccessTable);
414: // Video_CheckSyncShifterTable(Address,Byte,FrameCycles&511, pSyncScrollerAccessTable);
415: }
416:
417: //-----------------------------------------------------------------------
418: /*
419: Reset Sync/Shifter table at start of each HBL
420: */
421: void Video_StartHBL(void)
422: {
423: LeftRightBorder = 0;
424: }
425:
426: //-----------------------------------------------------------------------
427: /*
428: Store whole palette on first line so have reference to work from
429: */
430: void Video_StoreFirstLinePalette(void)
431: {
432: unsigned short int *pp2;
433: int i;
434:
435: pp2 = (unsigned short int *)((unsigned long)STRam+0xff8240);
436: for(i=0; i<16; i++)
437: HBLPalettes[i] = STMemory_Swap68000Int(*pp2++);
438: // And set mask flag with palette and resolution
439: HBLPaletteMasks[0] = (PALETTEMASK_RESOLUTION|PALETTEMASK_PALETTE) | (((unsigned long)STMemory_ReadByte(0xff8260)&0x3)<<16);
440: }
441:
442: //-----------------------------------------------------------------------
443: /*
444: Store resolution on each line(used to test if mixed low/medium resolutions)
445: */
446: void Video_StoreResolution(int y)
447: {
448: // Clear resolution, and set with current value
449: if (!(bUseHighRes || bUseVDIRes) ) {
450: HBLPaletteMasks[y] &= ~(0x3<<16);
451: HBLPaletteMasks[y] |= ((unsigned long)STMemory_ReadByte(0xff8260)&0x3)<<16;
452: }
453: }
454:
455: //-----------------------------------------------------------------------
456: /*
457: Copy line of screen into buffer for conversion later.
458: Possible lines may be top/bottom border, and/or left/right borders
459: */
460: void Video_CopyScreenLine(int BorderMask)
461: {
462: // Only copy screen line if not doing high VDI resolution
463: if (!bUseVDIRes) {
464: BorderMask |= LeftRightBorder;
465:
466: if (bUseHighRes) {
467: // Copy for hi-res(no overscan)
468: memcpy(pSTScreen,(char *)VideoRaster,SCREENBYTES_MIDDLE);
469: VideoRaster += SCREENBYTES_MIDDLE;
470: // Each screen line copied to buffer is always same length
471: pSTScreen += SCREENBYTES_MIDDLE;
472: }
473: else {
474: // Is total blank line? Ie top/bottom border?
475: if (BorderMask&(BORDERMASK_TOP|BORDERMASK_BOTTOM)) {
476: // Clear line to colour '0'
477: memset(pSTScreen,0,SCREENBYTES_LINE);
478: }
479: else {
480: // Does have left border? If not, clear to colour '0'
481: if (BorderMask&BORDERMASK_LEFT) {
482: VideoRaster += 24-SCREENBYTES_LEFT;
483: memcpy(pSTScreen,(char *)VideoRaster,SCREENBYTES_LEFT);
484: VideoRaster += SCREENBYTES_LEFT;
485: }
486: else
487: memset(pSTScreen,0,SCREENBYTES_LEFT);
488: // Copy middle - always present
489: memcpy(pSTScreen+SCREENBYTES_LEFT,(char *)VideoRaster,SCREENBYTES_MIDDLE);
490: VideoRaster += SCREENBYTES_MIDDLE;
491: // Does have right border? If not, clear to colour '0'
492: if (BorderMask&BORDERMASK_RIGHT) {
493: memcpy(pSTScreen+SCREENBYTES_LEFT+SCREENBYTES_MIDDLE,(char *)VideoRaster,SCREENBYTES_RIGHT);
494: VideoRaster += 46-SCREENBYTES_RIGHT;
495: VideoRaster += SCREENBYTES_RIGHT;
496: }
497: else
498: memset(pSTScreen+SCREENBYTES_LEFT+SCREENBYTES_MIDDLE,0,SCREENBYTES_RIGHT);
499: }
500:
501: // Each screen line copied to buffer is always same length
502: pSTScreen += SCREENBYTES_LINE;
503: }
504: }
505: }
506:
507: //-----------------------------------------------------------------------
508: /*
509: Copy extended GEM resolution screen
510: */
511: void Video_CopyVDIScreen(void)
512: {
513: // Copy whole screen, don't care about being exact as for GEM only
514: memcpy(pSTScreen,(char *)VideoRaster,((VDIWidth*VDIPlanes)/8)*VDIHeight); // 640x400x16colour
515: }
516:
517: //-----------------------------------------------------------------------
518: /*
519: Check at end of each HBL to see if any Sync/Shifter hardware tricks have been attempted
520: */
521: void Video_EndHBL(void)
522: {
523: // Are we in possible visible display(including borders)?
524: if ( (nHBL>=FIRST_VISIBLE_HBL) && (nHBL<(FIRST_VISIBLE_HBL+NUM_VISIBLE_LINES)) ) {
525: // Copy line of screen to buffer to simulate TV raster trace - required for mouse cursor display/game updates
526: // Eg, Lemmings and The Killing Game Show are good examples
527:
528: if (nHBL<nStartHBL) // Are we in top border blank(ie no top overscan enabled)
529: Video_CopyScreenLine(BORDERMASK_TOP);
530: else if (nHBL>=nEndHBL) // Are we in bottom border blank
531: Video_CopyScreenLine(BORDERMASK_BOTTOM);
532: else // Must be in visible screen(including overscan), ignore left/right borders for now
533: Video_CopyScreenLine(BORDERMASK_NONE);
534:
535: if (nHBL==FIRST_VISIBLE_HBL) { // Very first line on screen - HBLPalettes[0]
536: // Store ALL palette for this line into raster table for datum
537: Video_StoreFirstLinePalette();
538: }
539: // Store resolution for every line so can check for mix low/medium screens
540: Video_StoreResolution(nHBL-FIRST_VISIBLE_HBL);
541: }
542:
543: // Finally increase HBL count
544: nHBL++;
545:
546: Video_StartHBL(); // Setup next one
547: }
548:
549: // Clear raster line table to store changes in palette/resolution on a line basic
550: // Call once on VBL interrupt
551: void Video_SetScreenRasters(void)
552: {
553: pHBLPaletteMasks = HBLPaletteMasks;
554: pHBLPalettes = HBLPalettes;
555: Memory_Clear(pHBLPaletteMasks,sizeof(unsigned long)*NUM_VISIBLE_LINES);
556: }
557:
558: //-----------------------------------------------------------------------
559: /*
560: Set pointers to HBLPalette tables to store correct colours/resolutions
561: */
562: void Video_SetHBLPaletteMaskPointers(void)
563: {
564: int FrameCycles;
565: int Line;
566:
567: /* Top of standard screen is 64 lines from VBL(64x512=32768 cycles) */
568: /* Each line is 64+320+64+64(Blank) = 512 pixels per scan line */
569: /* Timer occurs at end of 64+320+64; Display Enable(DE)=Low */
570: /* HBL is incorrect on machine and occurs around 96+ cycles in */
571:
572: /* Top of standard screen is 64 lines from VBL(64x512=32768 cycles) */
573: /* Each line is 96 + 320 + 96 = 512 pixels per scan line(each pixel is one cycle) */
574: FrameCycles = Int_FindFrameCycles();
575:
576: /* Find 'line' into palette - screen starts 64 lines down, less 28 for top overscan */
577: /* And if write to last 96 cycle of line it will count as the NEXT line(needed else games may flicker) */
578: Line = (FrameCycles-(FIRST_VISIBLE_HBL*CYCLES_PER_LINE)+SCREEN_START_CYCLE)/CYCLES_PER_LINE;
579: if (Line<0) /* Limit to top/bottom of possible visible screen */
580: Line = 0;
581: if (Line>=NUM_VISIBLE_LINES)
582: Line = NUM_VISIBLE_LINES-1;
583:
584: // Store pointers
585: pHBLPaletteMasks = &HBLPaletteMasks[Line]; /* Next mask entry */
586: pHBLPalettes = &HBLPalettes[16*Line]; /* Next colour raster list x16 colours */
587: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.