![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to events.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 / cpu|
Return to events.c CVS log | Up to [HATARI the Atari ST Emulator] / hatari / src / cpu |
1.1 root 1: /*
2: * UAE - The Un*x Amiga Emulator
3: *
4: * Event stuff
5: *
6: * Copyright 1995-2002 Bernd Schmidt
7: * Copyright 1995 Alessandro Bissacco
8: * Copyright 2000-2012 Toni Wilen
9: */
10:
11: #include "main.h"
12:
13: #include "sysconfig.h"
14: #include "sysdeps.h"
15:
16: #include "options_cpu.h"
17: #include "events.h"
18: #include "memory.h"
19: #include "newcpu.h"
20: //#include "uae/ppc.h"
21:
22: static const int pissoff_nojit_value = 256 * CYCLE_UNIT;
23:
24: #ifndef WINUAE_FOR_HATARI
25: unsigned long int event_cycles, nextevent, currcycle;
26: int is_syncline, is_syncline_end;
27: long cycles_to_next_event;
28: long max_cycles_to_next_event;
29: long cycles_to_hsync_event;
30: unsigned long start_cycles;
31: bool event_wait;
32:
33: frame_time_t vsyncmintime, vsyncmaxtime, vsyncwaittime;
34: int vsynctimebase;
35: int event2_count;
36:
37: void events_schedule (void)
38: {
39: int i;
40:
41: unsigned long int mintime = ~0L;
42: for (i = 0; i < ev_max; i++) {
43: if (eventtab[i].active) {
44: unsigned long int eventtime = eventtab[i].evtime - currcycle;
45: if (eventtime < mintime)
46: mintime = eventtime;
47: }
48: }
49: nextevent = currcycle + mintime;
50: }
51: #endif
52:
53: void do_cycles_slow (unsigned long cycles_to_add)
54: {
55: #ifndef WINUAE_FOR_HATARI
56: if ((pissoff -= cycles_to_add) >= 0)
57: return;
58:
59: cycles_to_add = -pissoff;
60: pissoff = 0;
61:
62: while ((nextevent - currcycle) <= cycles_to_add) {
63: int i;
64:
65: /* Keep only CPU emulation running while waiting for sync point. */
66: if (is_syncline) {
67: if (!vblank_found_chipset) {
68: if (is_syncline > 0) {
69: int rpt = read_processor_time ();
70: int v = rpt - vsyncmintime;
71: int v2 = rpt - is_syncline_end;
72: if (v > vsynctimebase || v < -vsynctimebase) {
73: v = 0;
74: }
75: if (v < 0 && v2 < 0 && event_wait) {
76:
77: #ifdef WITH_PPC
78: if (ppc_state) {
79: if (is_syncline == 1) {
80: uae_ppc_execute_check();
81: } else {
82: uae_ppc_execute_quick();
83: }
84: }
85: #endif
86: if (currprefs.cachesize)
87: pissoff = pissoff_value;
88: else
89: pissoff = pissoff_nojit_value;
90: return;
91: }
92: } else if (is_syncline < 0) {
93: int rpt = read_processor_time ();
94: int v = rpt - is_syncline_end;
95: if (v < 0 && event_wait) {
96:
97: #ifdef WITH_PPC
98: if (ppc_state) {
99: uae_ppc_execute_check();
100: }
101: #endif
102: if (currprefs.cachesize)
103: pissoff = pissoff_value;
104: else
105: pissoff = pissoff_nojit_value;
106: return;
107: }
108: }
109: }
110: is_syncline = 0;
111: }
112:
113: cycles_to_add -= nextevent - currcycle;
114: currcycle = nextevent;
115:
116: for (i = 0; i < ev_max; i++) {
117: if (eventtab[i].active && eventtab[i].evtime == currcycle) {
118: if (eventtab[i].handler == NULL) {
119: gui_message(_T("eventtab[%d].handler is null!\n"), i);
120: eventtab[i].active = 0;
121: } else {
122: (*eventtab[i].handler)();
123: }
124: }
125: }
126: events_schedule ();
127:
128:
129: }
130: #endif
131: currcycle += cycles_to_add;
132: }
133:
134: #ifndef WINUAE_FOR_HATARI
135: void MISC_handler (void)
136: {
137: static bool dorecheck;
138: bool recheck;
139: int i;
140: evt mintime;
141: evt ct = get_cycles ();
142: static int recursive;
143:
144: if (recursive) {
145: dorecheck = true;
146: return;
147: }
148: recursive++;
149: eventtab[ev_misc].active = 0;
150: recheck = true;
151: while (recheck) {
152: recheck = false;
153: mintime = ~0L;
154: for (i = 0; i < ev2_max; i++) {
155: if (eventtab2[i].active) {
156: if (eventtab2[i].evtime == ct) {
157: eventtab2[i].active = false;
158: event2_count--;
159: eventtab2[i].handler (eventtab2[i].data);
160: if (dorecheck || eventtab2[i].active) {
161: recheck = true;
162: dorecheck = false;
163: }
164: } else {
165: evt eventtime = eventtab2[i].evtime - ct;
166: if (eventtime < mintime)
167: mintime = eventtime;
168: }
169: }
170: }
171: }
172: if (mintime != ~0UL) {
173: eventtab[ev_misc].active = true;
174: eventtab[ev_misc].oldcycles = ct;
175: eventtab[ev_misc].evtime = ct + mintime;
176: events_schedule ();
177: }
178: recursive--;
179: }
180:
181:
182: void event2_newevent_xx (int no, evt t, uae_u32 data, evfunc2 func)
183: {
184: evt et;
185: static int next = ev2_misc;
186:
187: et = t + get_cycles ();
188: if (no < 0) {
189: no = next;
190: for (;;) {
191: if (!eventtab2[no].active) {
192: event2_count++;
193: break;
194: }
195: if (eventtab2[no].evtime == et && eventtab2[no].handler == func && eventtab2[no].data == data)
196: break;
197: no++;
198: if (no == ev2_max)
199: no = ev2_misc;
200: if (no == next) {
201: write_log (_T("out of event2's!\n"));
202: return;
203: }
204: }
205: next = no;
206: }
207: eventtab2[no].active = true;
208: eventtab2[no].evtime = et;
209: eventtab2[no].handler = func;
210: eventtab2[no].data = data;
211: MISC_handler ();
212: }
213:
214: int current_hpos (void)
215: {
216: int hp = current_hpos_safe ();
217: if (hp < 0 || hp > 256) {
218: gui_message(_T("hpos = %d!?\n"), hp);
219: hp = 0;
220: }
221: return hp;
222: }
223: #endif
224:
225:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.