Return to events.h CVS log

Up to [UNIX Amiga Emulator] / uae / src / include

Annotation of uae/src/include/events.h, revision 1.1.1.2

1.1       root        1:  /*
                      2:   * UAE - The Un*x Amiga Emulator
                      3:   *
                      4:   * Events
                      5:   * 
                      6:   * (c) 1995 Bernd Schmidt
                      7:   */
                      8: 
                      9: extern unsigned long int cycles, nextevent;
                     10: typedef void (*evfunc)(void);
                     11: 
                     12: struct ev
                     13: {
                     14:     int active;
                     15:     unsigned long int evtime, oldcycles;
                     16:     evfunc handler;
                     17: };
                     18: 
                     19: enum { 
                     20:     ev_hsync, ev_copper, ev_cia,
                     21:     ev_blitter, ev_diskblk, ev_diskindex,
                     22: #ifndef DONT_WANT_SOUND
                     23:     ev_aud0, ev_aud1, ev_aud2, ev_aud3,
                     24:     ev_sample,
                     25: #endif
                     26:     ev_max
                     27: };
                     28: 
                     29: extern struct ev eventtab[ev_max];
                     30: 
                     31: static __inline__ void events_schedule(void)
                     32: {
                     33:     int i;
                     34:     
                     35:     unsigned long int mintime = ~0L;
                     36:     for(i = 0; i < ev_max; i++) {
                     37:        if (eventtab[i].active) {           
                     38:            unsigned long int eventtime = eventtab[i].evtime - cycles;
                     39:            if (eventtime < mintime)
                     40:                mintime = eventtime;
                     41:        }
                     42:     }
                     43:     nextevent = cycles + mintime;
                     44: }
                     45: 
                     46: static __inline__ void do_cycles_slow(void)
                     47: {
1.1.1.2 ! root       48:     if ((nextevent - cycles) <= M68K_SPEED) {
1.1       root       49:        int j;
1.1.1.2 ! root       50:        for(j = 0; j < M68K_SPEED; j++) {
1.1       root       51:            if (++cycles == nextevent) {
                     52:                int i;
                     53:                
                     54:                for(i = 0; i < ev_max; i++) {
                     55:                    if (eventtab[i].active && eventtab[i].evtime == cycles) {
                     56:                        (*eventtab[i].handler)();
                     57:                    }
                     58:                }
                     59:                events_schedule();
                     60:            }
                     61:        }
                     62:     } else {
1.1.1.2 ! root       63:        cycles += M68K_SPEED;
1.1       root       64:     }
                     65: }
                     66: 
                     67: static __inline__ void do_cycles_fast(void)
                     68: {
                     69:     cycles++;
                     70:     if (nextevent == cycles) {
                     71:        int i;
                     72:                
                     73:        for(i = 0; i < ev_max; i++) {
                     74:            if (eventtab[i].active && eventtab[i].evtime == cycles) {
                     75:                (*eventtab[i].handler)();
                     76:            }
                     77:        }
                     78:        events_schedule();
                     79:     }
                     80: 
                     81: }
                     82: 
1.1.1.2 ! root       83: #if M68K_SPEED == 1
1.1       root       84: #define do_cycles do_cycles_fast
                     85: #else
                     86: #define do_cycles do_cycles_slow
                     87: #endif

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.