![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to clocks_timings.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 clocks_timings.c CVS log | Up to [HATARI the Atari ST Emulator] / hatari / src |
1.1 root 1: /*
2: Hatari - clocks_timings.c
3:
1.1.1.2 root 4: This file is distributed under the GNU General Public License, version 2
5: or at your option any later version. Read the file gpl.txt for details.
1.1 root 6:
7: Clocks Timings for the hardware components in each supported machine type,
8: as well as functions taking into account the exact length of a VBL to
9: precisely emulate video/audio parts (number of VBL per sec, number of
10: audio samples per VBL, ...)
11:
12: The video freq is not exactly 50 or 60 Hz because the number of cpu cycles
13: per second is not a multiple of the number of cpu cycles per VBL.
14: This can cause synchronisation errors between audio and video effects
15: when both components use different clocks (eg in STE where audio DMA clock
16: is not the same as the cpu clock).
17:
18: To get the best results, it's recommanded to set RoundVBLPerSec=false.
19:
20: Note that if you do so, the number of VBL won't be exactly 50 or 60 per sec
21: but 50.05 or 60.04 ; if this does not work with your display, set RoundVBLPerSec=true
22: to get an integer number of VBL per sec (but this should not be needed).
23:
24:
25:
26: ST :
27: MCLK = 32 MHz
28: SHIFTER IN = 32 MHz OUT = 16 MHz
29: MMU IN = 16 MHz OUT = 8 MHz, 4 MHz
30: GLUE IN = 8 MHz OUT = 2 MHz, 500 kHz
31: BUS = 8 MHz
32:
33: CPU 68000 IN = 8 MHz
34: DMA IN = 8 MHz
35: MFP 68901 IN = 4 MHz, 2.4576 MHz (external clock)
36: FDC WD1772 IN = 8 MHz
37: BLITTER IN = 8 MHz
38: YM2149 IN = 2 MHz
39: ACIA MC6850 IN = 500 kHz
40: IKBD HD6301 IN = 1 MHZ (local clock)
41:
42:
43: STE :
44: MCLK = 32 MHz
45: EXT OSC = 8 MHZ OUT = 8 MHz (SCLK), 2 MHz (CLK2)
46: GST SHIFTER IN = 32 MHz, 8 MHz (external clock SCLK) OUT = 16 MHz, 8 MHz (FCLK=SCLK)
47: GST MCU IN = 16 MHz OUT = 8 MHz (CLK8), 4 MHz (CLK4), 500 kHz (KHZ500)
48: BUS = 8 MHz
49:
50: CPU 68000 IN = 8 MHz (CLK8)
51: DMA IN = 8 MHz (CLK8)
52: DMA AUDIO IN = 8 MHz (SCLK)
53: MFP 68901 IN = 4 MHz (CLK4), 2.4576 MHz (external clock)
54: FDC WD1772 IN = 8 MHz (SCLK)
55: BLITTER IN = 8 MHz (CLK8)
56: YM2149 IN = 2 MHz (CLK2)
57: ACIA MC6850 IN = 500 kHz (KHZ500)
58: IKBD HD6301 IN = 1 MHZ (local clock)
59:
60:
61: MEGA STE :
62: MCLK = 32 MHz
63: SCLK = 8 MHz
64: GST SHIFTER IN = 32 MHz, 8 MHz (external clock SCLK) OUT = 16 MHz (CLK16), 8 MHz (FCLK=SCLK)
65: GST MCU IN = 16 MHz (CLK16) OUT = 8 MHz (CLK8), 4 MHz (CLK4), 500 kHz (KHZ500)
66: BUS = 8 MHz
67:
68: CPU 68000 IN = 16 MHz (CLK16)
69: FPU 68881 IN = 16 MHz (CLK16)
70: DMA IN = 8 MHz (CLK8)
71: DMA AUDIO IN = 8 MHz (SCLK)
72: MFP 68901 IN = 4 MHz (CLK4), 2.4576 MHz (external clock)
73: FDC WD1772 IN = 8 MHz (SCLK)
74: BLITTER IN = 8 MHz (CLK8)
75: YM2149 IN = 2 MHz (CLK2 = SCLK / 4)
76: ACIA MC6850 IN = 500 kHz (KHZ500)
77: IKBD HD6301 IN = 1 MHZ (local clock)
78:
79:
80: TT :
81: MCLK = 32 MHz (CLK32)
82: TT VIDEO IN = 32 MHz (CLK32) OUT = 16 MHz (CLK16), 4 MHz (CLK4), 2 MHz (CLK2)
83: GST MCU IN = 16 MHz (CLK16A), 2 MHz (CLK2) OUT = 8 MHz (CLK8), 8 MHz (FCCLK), 1 MHz (CLKE), 500 kHz (CLKX5)
84: BUS = 16 MHz
85:
86: CPU 68030 IN = 32 MHz (CLK32)
87: FPU 68882 IN = 32 MHz (CLK32)
88: DMA IN = 8 MHz (CLK8)
89: SND SHIFTER IN = 16 MHz (CLK16F), 2 MHz (CLK2) OUT = ? MHz (FCLK)
90: MFP 68901 IN = 4 MHz (CLK4), 2.4576 MHz (external clock) NOTE : TT has 2 MFPs 68901
91: FDC WD1772 IN = 8 MHz (FCCLK)
92: BLITTER NOT AVAILABLE
93: YM2149 IN = 2 MHz (CLK2)
94: ACIA MC6850 IN = 500 kHz (CLKX5)
95: IKBD HD6301 IN = 1 MHZ (local clock)
96:
97:
98: FALCON :
99: MCLK = 32 MHz (CLK32)
100: VIDEL IN = 32 MHz (VID32MHZ), 25 MHz (25K)
101: COMBEL IN = 32 MHz (CLK32) OUT = 4 MHz (CLK4), 500 kHz (KHZ500)
102: BUS = 16 MHz
103:
104: CPU 68030 IN = 16 MHz (CPUCLKB)
105: FPU 68882 IN = 16 MHz (CPUCLKA)
106: DMA IN = 8 MHz (CLK8)
107: CODEC IN = 25 MHz (25K)
108: MFP 68901 IN = 4 MHz (CLK4), 2.4576 MHz (external clock)
109: FDC AJAX IN = 16 MHz (FCCLK)
110: BLITTER IN = 16 MHz
111: YM3439 IN = 2 MHz (CLK2)
112: ACIA MC6850 IN = 500 kHz (KHZ500)
113: IKBD HD6301 IN = 1 MHZ (local clock)
114:
115: DSP 56001 IN = 32 MHz (DSP_32M)
116:
117: */
118:
119:
120: const char ClocksTimings_fileid[] = "Hatari clocks_timings.c : " __DATE__ " " __TIME__;
121:
122: #include <SDL.h>
123: #include <SDL_endian.h>
124:
125: #include "main.h"
126: #include "configuration.h"
127: #include "log.h"
128: #include "clocks_timings.h"
129:
130:
131:
132: /* The possible master frequencies used in the different machines */
133: /* depending on PAL/NTSC version. */
134:
135: #define ATARI_STF_PAL_MCLK 32084988 /* CPU_Freq = 8.021247 MHz */
136: #define ATARI_STF_NTSC_MCLK 32042400 /* CPU_Freq = 8.010600 MHz */
137: #define ATARI_STF_CYCLES_PER_VBL_PAL 160256 /* 512 cycles * 313 lines */
138: #define ATARI_STF_CYCLES_PER_VBL_NTSC 133604 /* 508 cycles * 263 lines */
139: #define ATARI_STF_CYCLES_PER_VBL_HI 112224 /* 224 cycles * 501 lines */
140:
141: #define ATARI_STE_PAL_MCLK 32084988 /* CPU_Freq = 8.021247 MHz */
142: #define ATARI_STE_NTSC_MCLK 32215905 /* CPU_Freq = 8.05397625 MHz */
143: #define ATARI_STE_EXT_OSC 8010613 /* OSC U303 */
144: #define ATARI_STE_CYCLES_PER_VBL_PAL 160256 /* 512 cycles * 313 lines */
145: #define ATARI_STE_CYCLES_PER_VBL_NTSC 133604 /* 508 cycles * 263 lines */
146: #define ATARI_STE_CYCLES_PER_VBL_HI 112224 /* 224 cycles * 501 lines */
147:
148: #define ATARI_MEGA_STE_PAL_MCLK 32084988 /* CPU_Freq = 16.042494 MHz */
149: #define ATARI_MEGA_STE_NTSC_MCLK 32215905 /* CPU_Freq = 16.1079525 MHz */
150: #define ATARI_MEGA_STE_EXT_OSC 16021226 /* OSC U408 */
151:
152: #define ATARI_TT_PAL_MCLK 32084988 /* CPU_Freq = 32.084988 MHz */
153: #define ATARI_TT_NTSC_MCLK 32215905 /* CPU_Freq = 32.215905 MHz */
154:
155: #define ATARI_FALCON_PAL_MCLK 32084988 /* CPU_Freq = 16.042494 MHz */
156: #define ATARI_FALCON_NTSC_MCLK 32215905 /* CPU_Freq = 16.1079525 MHz */
157: #define ATARI_FALCON_25M_CLK 25175000
158:
159: #define ATARI_MFP_XTAL 2457600 /* external clock for the MFP */
160: #define ATARI_IKBD_CLK 1000000 /* clock of the HD6301 ikbd cpu */
161:
162:
163:
164: CLOCKS_STRUCT MachineClocks;
165:
166:
167: bool RoundVBLPerSec = false; /* if false, don't round number of VBL to 50/60 Hz */
168: /* but compute the exact value based on cpu/video clocks */
169:
170:
171:
172:
173: /*--------------------------------------------------------------------------*/
174: /**
175: * Initialize all the clocks informations related to a specific machine type.
176: * We consider the machine is running with PAL clocks.
177: */
178:
179: void ClocksTimings_InitMachine ( MACHINETYPE MachineType )
180: {
181: memset ( (void *)&MachineClocks , 0 , sizeof ( MachineClocks ) );
182:
1.1.1.3 ! root 183: if (MachineType == MACHINE_ST || MachineType == MACHINE_MEGA_ST)
1.1 root 184: {
185: int CLK16, CLK8, CLK4, CLK2, CLK500;
186:
187: MachineClocks.MCLK_Freq = ATARI_STF_PAL_MCLK; /* 32.084988 MHz */
188:
189: MachineClocks.SHIFTER_Freq = MachineClocks.MCLK_Freq; /* 32 MHz */
190: CLK16 = MachineClocks.SHIFTER_Freq / 2;
191:
192: MachineClocks.MMU_Freq = CLK16; /* 16 MHz */
193: CLK8 = MachineClocks.MMU_Freq / 2;
194: CLK4 = MachineClocks.MMU_Freq / 4;
195:
196: MachineClocks.GLUE_Freq = CLK8; /* 8 MHz */
197: CLK2 = MachineClocks.GLUE_Freq / 4;
198: CLK500 = MachineClocks.GLUE_Freq / 16;
199:
200: MachineClocks.BUS_Freq = CLK8; /* 8 MHz */
201:
202: MachineClocks.CPU_Freq = CLK8; /* 8 MHz */
203: MachineClocks.DMA_Freq = CLK8; /* 8 MHz */
204: MachineClocks.MFP_Freq = CLK4; /* 4 MHz */
205: MachineClocks.MFP_Timer_Freq = ATARI_MFP_XTAL; /* 2.4576 MHz (XTAL)*/
206: MachineClocks.FDC_Freq = CLK8; /* 8 MHz */
207: MachineClocks.BLITTER_Freq = CLK8; /* 8 MHz */
208: MachineClocks.YM_Freq = CLK2; /* 2 MHz */;
209: MachineClocks.ACIA_Freq = CLK500; /* 500 kHz */
210: MachineClocks.IKBD_Freq = ATARI_IKBD_CLK; /* 1 MHz */
211: }
212:
213: else if ( MachineType == MACHINE_STE )
214: {
215: int SCLK, CLK16, CLK8, CLK4, CLK2, KHZ500;
216: //int FCLK; /* not used (audio filters) */
217:
218: MachineClocks.MCLK_Freq = ATARI_STE_PAL_MCLK; /* 32.084988 MHz */
219: SCLK = ATARI_STE_EXT_OSC; /* 8.010613 MHz (SCLK) */
220: CLK2 = SCLK / 4;
221:
222: MachineClocks.SHIFTER_Freq = MachineClocks.MCLK_Freq; /* 32 MHz */
223: CLK16 = MachineClocks.SHIFTER_Freq / 2;
224: //FCLK = SCLK;
225:
226: MachineClocks.MCU_Freq = CLK16; /* 16 MHz */
227: CLK8 = MachineClocks.MCU_Freq / 2;
228: CLK4 = MachineClocks.MCU_Freq / 4;
229: KHZ500 = MachineClocks.MCU_Freq / 32;
230:
231: MachineClocks.BUS_Freq = CLK8; /* 8 MHz (CLK8) */
232:
233: MachineClocks.CPU_Freq = CLK8; /* 8 MHz (CLK8) */
234: MachineClocks.DMA_Freq = CLK8; /* 8 MHz (CLK8) */
235: MachineClocks.DMA_Audio_Freq = SCLK; /* 8 MHz (SCLK) */
236: MachineClocks.MFP_Freq = CLK4; /* 4 MHz (CLK4) */
237: MachineClocks.MFP_Timer_Freq = ATARI_MFP_XTAL; /* 2.4576 MHz (XTAL)*/
238: MachineClocks.FDC_Freq = SCLK; /* 8 MHz (SCLK) */
239: MachineClocks.BLITTER_Freq = CLK8; /* 8 MHz (CLK8) */
240: MachineClocks.YM_Freq = CLK2; /* 2 MHz (CLK2) */
241: MachineClocks.ACIA_Freq = KHZ500; /* 500 kHz (KHZ500) */
242: MachineClocks.IKBD_Freq = ATARI_IKBD_CLK; /* 1 MHz */
243: }
244:
245: else if ( MachineType == MACHINE_MEGA_STE )
246: {
247: int SCLK, CLK16, CLK8, CLK4, CLK2, KHZ500;
248: //int FCLK; /* not used (audio filters) */
249:
250: MachineClocks.MCLK_Freq = ATARI_MEGA_STE_PAL_MCLK; /* 32.084988 MHz */
251: SCLK = ATARI_MEGA_STE_EXT_OSC / 2; /* 16.021226 MHz / 2 = 8.010613 MHz */
252: CLK2 = SCLK / 4;
253:
254: MachineClocks.SHIFTER_Freq = MachineClocks.MCLK_Freq; /* 32 MHz */
255: CLK16 = MachineClocks.SHIFTER_Freq / 2;
256: //FCLK = SCLK;
257:
258: MachineClocks.MCU_Freq = CLK16; /* 16 MHz (CLK16) */
259: CLK8 = MachineClocks.MCU_Freq / 2;
260: CLK4 = MachineClocks.MCU_Freq / 4;
261: KHZ500 = MachineClocks.MCU_Freq / 32;
262:
263: MachineClocks.BUS_Freq = CLK8; /* 8 MHz (CLK8) */
264:
1.1.1.3 ! root 265: /* Special case : the Mega STE has an internal 16 MHz CPU clock */
! 266: /* but it can be set to 8 MHz for compatibility with STE using $FF8E21 */
! 267: /* We use 8 MHz here to get correct cycles and sound samples per VBL */
! 268: // MachineClocks.CPU_Freq = CLK16; /* 16 MHz (CLK16) */
! 269: MachineClocks.CPU_Freq = CLK8; /* 8 MHz (CLK8) */
! 270:
1.1 root 271: MachineClocks.FPU_Freq = CLK16; /* 16 MHz (CLK16) */
272: MachineClocks.DMA_Freq = CLK8; /* 8 MHz (CLK8) */
273: MachineClocks.DMA_Audio_Freq = SCLK; /* 8 MHz (SCLK) */
274: MachineClocks.MFP_Freq = CLK4; /* 4 MHz (CLK4) */
275: MachineClocks.MFP_Timer_Freq = ATARI_MFP_XTAL; /* 2.4576 MHz (XTAL)*/
276: MachineClocks.FDC_Freq = SCLK; /* 8 MHz (SCLK) */
277: MachineClocks.BLITTER_Freq = CLK8; /* 8 MHz (CLK8) */
278: MachineClocks.YM_Freq = CLK2; /* 2 MHz (CLK2) */
279: MachineClocks.ACIA_Freq = KHZ500; /* 500 kHz (KHZ500) */
280: MachineClocks.IKBD_Freq = ATARI_IKBD_CLK; /* 1 MHz */
281: }
282:
283: else if ( MachineType == MACHINE_TT )
284: {
285: int CLK32, CLK16, CLK8, FCCLK, CLK4, CLK2, CLKX5;
286:
287: MachineClocks.MCLK_Freq = ATARI_TT_PAL_MCLK; /* 32.084988 MHz */
288: CLK32 = MachineClocks.MCLK_Freq;
289:
290: MachineClocks.TTVIDEO_Freq = MachineClocks.MCLK_Freq; /* 32 MHz */
291: CLK16 = MachineClocks.TTVIDEO_Freq / 2;
292: CLK4 = MachineClocks.TTVIDEO_Freq / 8;
293: CLK2 = MachineClocks.TTVIDEO_Freq / 16;
294:
295: MachineClocks.MCU_Freq = CLK16; /* 16 MHz (CLK16A) */
296: CLK8 = MachineClocks.MCU_Freq / 2;
297: FCCLK = MachineClocks.MCU_Freq / 2;
298: CLKX5 = MachineClocks.MCU_Freq / 32;
299:
300: MachineClocks.BUS_Freq = CLK16; /* 16 MHz (CLK16) */
301:
302: MachineClocks.CPU_Freq = CLK32; /* 32 MHz (CLK32) */
303: MachineClocks.FPU_Freq = CLK32; /* 32 MHz (CLK32) */
304: MachineClocks.DMA_Freq = CLK8; /* 8 MHz (CLK8) */
305: MachineClocks.DMA_Audio_Freq = CLK16; /* 16 MHz (CLK16) SND SHIFTER */
306: MachineClocks.MFP_Freq = CLK4; /* 4 MHz (CLK4) */
307: MachineClocks.MFP_Timer_Freq = ATARI_MFP_XTAL; /* 2.4576 MHz (XTAL)*/
308: MachineClocks.FDC_Freq = FCCLK; /* 8 MHz (FCCLK) */
309: MachineClocks.BLITTER_Freq = 0; /* No blitter in TT */
310: MachineClocks.YM_Freq = CLK2; /* 2 MHz (CLK2) */
311: MachineClocks.ACIA_Freq = CLKX5; /* 500 kHz (CLKX5) */
312: MachineClocks.IKBD_Freq = ATARI_IKBD_CLK; /* 1 MHz */
313: }
314:
315: else if ( MachineType == MACHINE_FALCON )
316: {
317: /* TODO : need more docs for Falcon's clocks */
318: int CLK32, CLK25, CLK16, FCCLK, CLK4, CLK2, KHZ500;
319:
320: MachineClocks.MCLK_Freq = ATARI_FALCON_PAL_MCLK; /* 32.084988 MHz */
321: CLK32 = MachineClocks.MCLK_Freq;
322: CLK25 = ATARI_FALCON_25M_CLK;
323: CLK16 = CLK32 / 2;
324: CLK2 = CLK32 / 16;
325: FCCLK = CLK16;
326:
327: MachineClocks.VIDEL_Freq = CLK32; /* 32 MHz */
328:
329: MachineClocks.COMBEL_Freq = CLK32; /* 16 MHz (CLK16A) */
330: CLK4 = MachineClocks.COMBEL_Freq / 8;
331: KHZ500 = MachineClocks.COMBEL_Freq / 64;
332:
333: MachineClocks.BUS_Freq = CLK16; /* 16 MHz (CPUCLK16A) */
334: MachineClocks.CPU_Freq = CLK16; /* 16 MHz (CPUCLK16B) */
335: MachineClocks.FPU_Freq = CLK16; /* 16 MHz (CLK32) */
336: MachineClocks.DSP_Freq = CLK32; /* 32 MHz */
337: MachineClocks.DMA_Freq = CLK16; /* 16 MHz (CLK16) ? */
338: MachineClocks.CODEC_Freq = CLK25; /* 25 MHz (CLK25) */
339: MachineClocks.MFP_Freq = CLK4; /* 4 MHz (CLK4) */
340: MachineClocks.MFP_Timer_Freq = ATARI_MFP_XTAL; /* 2.4576 MHz (XTAL)*/
341: MachineClocks.FDC_Freq = FCCLK; /* 16 MHz (FCCLK) ? */
342: MachineClocks.BLITTER_Freq = CLK16; /* 16 MHz */
343: MachineClocks.YM_Freq = CLK2; /* 2 MHz (CLK2) */
344: MachineClocks.ACIA_Freq = KHZ500; /* 500 kHz (KHZ500) */
345: MachineClocks.IKBD_Freq = ATARI_IKBD_CLK; /* 1 MHz */
346: }
347:
348:
349: }
350:
351:
352:
353:
354:
355: /*-----------------------------------------------------------------------------------------*/
356: /**
357: * Return the number of VBL per second, depending on the video settings and the cpu freq.
358: * This value is only known for STF/STE running at 50, 60 or 71 Hz.
359: * For the other machines, we return CPU_Freq / ScreenRefreshRate
360: */
361:
362: Uint32 ClocksTimings_GetCyclesPerVBL ( MACHINETYPE MachineType , int ScreenRefreshRate )
363: {
364: Uint32 CyclesPerVBL;
365:
366:
367: CyclesPerVBL = MachineClocks.CPU_Freq / ScreenRefreshRate; /* default value */
368:
369: /* STF and STE have the same numbers of cycles per VBL */
1.1.1.3 ! root 370: if (MachineType == MACHINE_ST || MachineType == MACHINE_MEGA_ST
! 371: || MachineType == MACHINE_STE || MachineType == MACHINE_MEGA_STE)
1.1 root 372: {
373: if ( ScreenRefreshRate == 50 )
374: CyclesPerVBL = ATARI_STF_CYCLES_PER_VBL_PAL;
375: else if ( ScreenRefreshRate == 60 )
376: CyclesPerVBL = ATARI_STF_CYCLES_PER_VBL_NTSC;
377: else if ( ScreenRefreshRate == 71 )
378: CyclesPerVBL = ATARI_STF_CYCLES_PER_VBL_HI;
379: else
380: CyclesPerVBL = MachineClocks.CPU_Freq / ScreenRefreshRate; /* should not happen */
381: }
382:
383: /* For machines where cpu freq can be changed, we don't know the number of cycles per VBL */
384: /* -> TODO, for now comment code to keep the default value from above */
385: //else if ( ( MachineType == MACHINE_MEGA_STE ) || ( MachineType == MACHINE_TT ) || ( MachineType == MACHINE_FALCON ) )
386: // CyclesPerVBL = MachineClocks.CPU_Freq / ScreenRefreshRate;
387:
388:
389: return CyclesPerVBL;
390: }
391:
392:
393:
394:
395: /*-----------------------------------------------------------------------------------------*/
396: /**
397: * Return the number of VBL per second, depending on the video settings and the cpu freq.
398: * Since the cpu freq is not an exact multiple of the number of cycles per VBL, the real
399: * value slightly differs from the usual 50/60 Hz.
400: * Precise values are needed in STE mode to synchronize cpu and dma sound (as they both use
401: * 2 different clocks).
402: * example for STF/STE :
403: * PAL STF/STE video PAL : 50.053 VBL/sec
404: * PAL STF/STE video NTSC : 60.037 VBL/sec
405: * NTSC STF/STE video PAL : 49.986 VBL/sec
406: * NTSC STF/STE video NTSC : 59.958 VBL/sec
407: *
408: * The returned number of VBL per sec is << 24 (=CLOCKS_TIMINGS_SHIFT_VBL) to simulate floating point using Uint32.
409: */
410:
411: Uint32 ClocksTimings_GetVBLPerSec ( MACHINETYPE MachineType , int ScreenRefreshRate )
412: {
413: Uint32 VBLPerSec; /* Upper 8 bits are for int part, 24 lower bits for float part */
414:
415:
416: VBLPerSec = ScreenRefreshRate << CLOCKS_TIMINGS_SHIFT_VBL; /* default rounded value */
417:
418: if ( RoundVBLPerSec == false )
419: {
420: /* STF and STE have the same numbers of cycles per VBL */
1.1.1.3 ! root 421: if (MachineType == MACHINE_ST || MachineType == MACHINE_MEGA_ST
! 422: || MachineType == MACHINE_STE || MachineType == MACHINE_MEGA_STE)
1.1 root 423: VBLPerSec = ( (Sint64)MachineClocks.CPU_Freq << CLOCKS_TIMINGS_SHIFT_VBL ) / ClocksTimings_GetCyclesPerVBL ( MachineType , ScreenRefreshRate );
424:
425: /* For machines where cpu freq can be changed, we don't know the number of cycles per VBL */
426: /* -> TODO, for now comment code to keep the default value from above */
427: //else if ( ( MachineType == MACHINE_MEGA_STE ) || ( MachineType == MACHINE_TT ) || ( MachineType == MACHINE_FALCON ) )
428: // VBLPerSec = ScreenRefreshRate << CLOCKS_TIMINGS_SHIFT_VBL;
429: }
430:
431:
432: return VBLPerSec;
433: }
434:
435:
436:
437:
438: /*-----------------------------------------------------------------------------------------*/
439: /**
440: * Return the length in microsec of a VBL (opposite function of ClocksTimings_GetVBLPerSec)
441: * We use precise values only in STF/STE mode, else we use 1000000 / ScreenRefreshRate.
442: * example for STF/STE :
443: * PAL STF/STE video PAL : 19979 micro sec (instead of 20000 for 50 Hz)
444: * PAL STF/STE video NTSC : 16656 micro sec (instead of 16667 for 60 Hz)
445: */
446:
447: Uint32 ClocksTimings_GetVBLDuration_micro ( MACHINETYPE MachineType , int ScreenRefreshRate )
448: {
449: Uint32 VBLDuration_micro;
450:
451:
452: VBLDuration_micro = (Uint32) (1000000.0 / ScreenRefreshRate + 0.5); /* default rounded value, round to closest integer */
453:
454: if ( RoundVBLPerSec == false )
455: {
456: /* STF and STE have the same numbers of cycles per VBL */
1.1.1.3 ! root 457: if (MachineType == MACHINE_ST || MachineType == MACHINE_MEGA_ST
! 458: || MachineType == MACHINE_STE || MachineType == MACHINE_MEGA_STE)
1.1 root 459: VBLDuration_micro = (Uint32) (1000000.0 * ClocksTimings_GetCyclesPerVBL ( MachineType , ScreenRefreshRate ) / MachineClocks.CPU_Freq + 0.5);
460:
461: /* For machines where cpu freq can be changed, we don't know the number of cycles per VBL */
462: /* -> TODO, for now comment code to keep the default value from above */
463: //else if ( ( MachineType == MACHINE_MEGA_STE ) || ( MachineType == MACHINE_TT ) || ( MachineType == MACHINE_FALCON ) )
464: // VBLDuration_micro = (Uint32) (1000000.0 / ScreenRefreshRate + 0.5);
465: }
466:
467:
468: return VBLDuration_micro;
469: }
470:
471:
472:
473:
474: /*-----------------------------------------------------------------------------------------*/
475: /**
476: * Return the number of samples needed to emulate the sound that was produced during one VBL.
477: * This depends on the chosen audio output frequency, as well as the VBL's duration,
478: *
479: * We use precise values only in STF/STE mode, else we use AudioFreq/ScreenRefreshRate.
480: *
481: * The returned number of samples per VBL is << 28 to simulate maximum precision using
482: * 64 bits integers (lower 28 bits are for the floating point part).
483: * example for STF/STE with emulation's audio freq = 44100 :
484: * PAL STF/STE video PAL : 881.07 samples per VBL (instead of 882 for 50 Hz)
485: * 44053.56 samples for 50 VBLs (instead of 44100 for 1 sec at 50 Hz)
486: */
487:
488: Sint64 ClocksTimings_GetSamplesPerVBL ( MACHINETYPE MachineType , int ScreenRefreshRate , int AudioFreq )
489: {
490: Sint64 SamplesPerVBL;
491:
492:
493: SamplesPerVBL = ( ((Sint64)AudioFreq) << 28 ) / ScreenRefreshRate; /* default value */
494:
495: if ( RoundVBLPerSec == false )
496: {
497: /* STF and STE have the same numbers of cycles per VBL */
1.1.1.3 ! root 498: if (MachineType == MACHINE_ST || MachineType == MACHINE_MEGA_ST
! 499: || MachineType == MACHINE_STE || MachineType == MACHINE_MEGA_STE)
1.1 root 500: SamplesPerVBL = ( ((Sint64)AudioFreq * ClocksTimings_GetCyclesPerVBL ( MachineType , ScreenRefreshRate ) ) << 28 ) / MachineClocks.CPU_Freq;
501:
502: /* For machines where cpu freq can be changed, we don't know the number of cycles per VBL */
503: /* -> TODO, for now comment code to keep the default value from above */
504: //else if ( ( MachineType == MACHINE_MEGA_STE ) || ( MachineType == MACHINE_TT ) || ( MachineType == MACHINE_FALCON ) )
505: // SamplesPerVBL = ( ((Sint64)AudioFreq) << 28 ) / ScreenRefreshRate;
506: }
507:
508:
509: return SamplesPerVBL;
510: }
511:
512:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.