![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to os.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [UNIX Amiga Emulator] / uae / src|
Return to os.c CVS log | Up to [UNIX Amiga Emulator] / uae / src |
1.1 root 1: /*
2: * UAE - The Un*x Amiga Emulator
3: *
4: * OS specific functions
5: *
6: * (c) 1995 Bernd Schmidt
7: * (c) 1996 Marcus Sundberg
8: */
9:
10: #include "sysconfig.h"
11: #include "sysdeps.h"
12:
13: #include "config.h"
14: #include "options.h"
15: #include "memory.h"
16: #include "custom.h"
17: #include "os.h"
18: #include "events.h"
19:
20: #ifndef DONT_WANT_SOUND
21: static void sample16_handler(void);
22: static void sample8_handler(void);
23: #endif
24:
25: int joystickpresent = 0;
26:
27: #ifdef HAVE_LINUX_JOYSTICK_H
28:
29: static int js0;
30:
31: struct JS_DATA_TYPE jscal;
32:
33: void read_joystick(UWORD *dir, int *button)
34: {
35: static int minx = MAXINT, maxx = MININT,
36: miny = MAXINT, maxy = MININT;
37: int left = 0, right = 0, top = 0, bot = 0;
38: struct JS_DATA_TYPE buffer;
39: int len;
40:
41: *dir = 0;
42: *button = 0;
43: if (!joystickpresent)
44: return;
45:
46: len = read(js0, &buffer, sizeof(buffer));
47: if (len != sizeof(buffer))
48: return;
49:
50: if (buffer.x < minx) minx = buffer.x;
51: if (buffer.y < miny) miny = buffer.y;
52: if (buffer.x > maxx) maxx = buffer.x;
53: if (buffer.y > maxy) maxy = buffer.y;
54:
55: if (buffer.x < (minx + (maxx-minx)/3))
56: left = 1;
57: else if (buffer.x > (minx + 2*(maxx-minx)/3))
58: right = 1;
59:
60: if (buffer.y < (miny + (maxy-miny)/3))
61: top = 1;
62: else if (buffer.y > (miny + 2*(maxy-miny)/3))
63: bot = 1;
64:
65: if (left) top = !top;
66: if (right) bot = !bot;
67: *dir = bot | (right << 1) | (top << 8) | (left << 9);
68: *button = (buffer.buttons & 3) != 0;
69: }
70:
71: void init_joystick(void)
72: {
73: js0 = open("/dev/js0", O_RDONLY);
74: if (js0 < 0)
75: return;
76: joystickpresent = 1;
77: }
78:
79: void close_joystick(void)
80: {
81: if (joystickpresent)
82: close(js0);
83: }
84:
85: #elif defined(__DOS__)
86:
87: void read_joystick(UWORD *dir, int *button)
88: {
89: static int minx = MAXINT, maxx = MININT,
90: miny = MAXINT, maxy = MININT;
91: int left = 0, right = 0, top = 0, bot = 0;
92: char JoyPort;
93: int laps, JoyX, JoyY;
94:
95: *dir = 0;
96: *button = 0;
97: if (!joystickpresent)
98: return;
99:
100: JoyX = 0;
101: JoyY = 0;
102: laps = 0;
103: __asm__ __volatile__("cli");
104: outportb(0x201, 0xff);
105: do {
106: JoyPort = inportb(0x201);
107: JoyX = JoyX + (JoyPort & 1);
108: JoyY = JoyY + ((JoyPort & 2) >> 1);
109: laps++;
110: } while(((JoyPort & 3) != 0) && (laps != 65535));
111: __asm__ __volatile__("sti");
112:
113: if (JoyX < minx) minx = JoyX;
114: if (JoyY < miny) miny = JoyY;
115: if (JoyX > maxx) maxx = JoyX;
116: if (JoyY > maxy) maxy = JoyY;
117:
118: if (JoyX < (minx + (maxx-minx)/3))
119: left = 1;
120: else if (JoyX > (minx + 2*(maxx-minx)/3))
121: right = 1;
122:
123: if (JoyY < (miny + (maxy-miny)/3))
124: top = 1;
125: else if (JoyY > (miny + 2*(maxy-miny)/3))
126: bot = 1;
127:
128: if (left) top = !top;
129: if (right) bot = !bot;
130: *dir = bot | (right << 1) | (top << 8) | (left << 9);
131: *button = ((~JoyPort) & 48) != 0;
132: }
133:
134: void init_joystick(void)
135: {
136: int laps = 0;
137: char JoyPort;
138: __asm__ __volatile__("cli");
139: outportb(0x201, 0xff);
140: do {
141: JoyPort = inportb(0x201);
142: laps++;
143: } while(((JoyPort & 3) != 0) && (laps != 65535));
144: __asm__ __volatile__("sti");
145: if (laps != 65535)
146: joystickpresent = 1;
147: }
148:
149: void close_joystick(void)
150: {
151: }
152:
153: #else
154: void read_joystick(UWORD *dir, int *button)
155: {
156: *dir = 0;
157: *button = 0;
158: }
159:
160: void init_joystick(void)
161: {
162: }
163:
164: void close_joystick(void)
165: {
166: }
167:
168: #endif
169:
170: int sound_available = 0;
171: static long count = 0;
172:
173: struct audio_channel_data audio_channel[4];
174:
175: /* The buffer is too large... */
176: static UWORD buffer[44100], *bufpt;
177:
178: static ULONG data;
179:
180: int sound_table[256][64];
181: static int smplcnt = 0;
182: static int dspbits = 16, freq_divisor = 1;
183: static int sndbufsize;
184:
185: static void init_sound_table16(void)
186: {
187: int i,j;
188:
189: for (i = 0; i < 256; i++)
190: for (j = 0; j < 64; j++)
191: sound_table[i][j] = j * (BYTE)i;
192: }
193:
194: static void init_sound_table8(void)
195: {
196: int i,j;
197:
198: for (i = 0; i < 256; i++)
199: for (j = 0; j < 64; j++)
200: sound_table[i][j] = (j * (BYTE)i) / 256;
201: }
202:
203: static int exact_log2(int v)
204: {
205: int l = 0;
206: while ((v >>= 1) != 0)
207: l++;
208: return l;
209: }
210:
211: #ifdef LINUX_SOUND
212:
213: #include <sys/ioctl.h>
214: #include <sys/soundcard.h>
215:
216: static int sfd;
217: static int have_sound;
218:
219: int init_sound (void)
220: {
221: int tmp;
222: int rate;
223:
224: unsigned long formats;
225:
226: sfd = open ("/dev/dsp", O_WRONLY);
227: have_sound = !(sfd < 0);
228: if (!have_sound) {
229: return 0;
230: }
231:
232: ioctl (sfd, SNDCTL_DSP_GETFMTS, &formats);
233:
234: if (sound_desired_bsiz < 128 || sound_desired_bsiz > 16384) {
235: fprintf(stderr, "Sound buffer size %d out of range.\n", sound_desired_bsiz);
236: sound_desired_bsiz = 8192;
237: }
238:
239: tmp = 0x00040000 + exact_log2(sound_desired_bsiz);
240: ioctl (sfd, SNDCTL_DSP_SETFRAGMENT, &tmp);
241: ioctl (sfd, SNDCTL_DSP_GETBLKSIZE, &sndbufsize);
242:
243: dspbits = sound_desired_bits;
244: ioctl(sfd, SNDCTL_DSP_SAMPLESIZE, &dspbits);
245: ioctl(sfd, SOUND_PCM_READ_BITS, &dspbits);
246: if (dspbits != sound_desired_bits) {
247: fprintf(stderr, "Can't use sound with %d bits\n", sound_desired_bits);
248: return 0;
249: }
250:
251: tmp = 0;
252: ioctl(sfd, SNDCTL_DSP_STEREO, &tmp);
253:
254: rate = sound_desired_freq;
255: ioctl(sfd, SNDCTL_DSP_SPEED, &rate);
256: ioctl(sfd, SOUND_PCM_READ_RATE, &rate);
257: /* Some soundcards have a bit of tolerance here. */
258: if (rate < sound_desired_freq * 90 / 100 || rate > sound_desired_freq * 110 / 100) {
259: fprintf(stderr, "Can't use sound with desired frequency %d\n", sound_desired_freq);
260: return 0;
261: }
262:
263: eventtab[ev_sample].evtime = (long)maxhpos * maxvpos * 50 / rate;
264:
265: if (dspbits == 16) {
266: /* Will this break horribly on Linux/Alpha? Possible... */
267: if (!(formats & AFMT_S16_LE))
268: return 0;
269: init_sound_table16 ();
270: eventtab[ev_sample].handler = sample16_handler;
271: } else {
272: if (!(formats & AFMT_U8))
273: return 0;
274: init_sound_table8 ();
275: eventtab[ev_sample].handler = sample8_handler;
276: }
277: sound_available = 1;
278: printf ("Sound driver found and configured for %d bits at %d Hz, buffer is %d bytes\n",
279: dspbits, rate, sndbufsize);
280: bufpt = buffer;
281: smplcnt = 0;
282: return 1;
283: }
284:
285: static void flush_sound_buffer(void)
286: {
287: write(sfd, buffer, sndbufsize);
288: bufpt = buffer;
289: }
290:
291: #elif defined(AF_SOUND)
292:
293: #include <AF/AFlib.h>
294:
295: static AFAudioConn *aud;
296: static AC ac;
297: static long aftime;
298: static int rate;
299:
300: static int have_sound;
301:
302: int init_sound (void)
303: {
304: AFSetACAttributes attributes;
305: AFDeviceDescriptor *aDev;
306: int device;
307:
308: aud = AFOpenAudioConn(NULL);
309: have_sound = !(aud == NULL);
310: if (!have_sound) {
311: return 0;
312: }
313:
314: for(device = 0; device < ANumberOfAudioDevices(aud); device++) {
315: aDev = AAudioDeviceDescriptor(aud, device);
316: rate = aDev->playSampleFreq;
317: sndbufsize = (rate / 8) * 4;
318: if(aDev->inputsFromPhone == 0
319: && aDev->outputsToPhone == 0
320: && aDev->playNchannels == 1)
321: break;
322: }
323: if (device == ANumberOfAudioDevices(aud)) {
324: return 0;
325: }
326:
327: dspbits = 16;
328: attributes.type = LIN16;
329: ac = AFCreateAC(aud, device, ACEncodingType, &attributes);
330: aftime = AFGetTime(ac);
331:
332: init_sound_table16 ();
333: eventtab[ev_sample].handler = sample16_handler;
334: eventtab[ev_sample].evtime = (long)maxhpos * maxvpos * 50 / rate;
335:
336: bufpt = buffer;
337: smplcnt = 0;
338: sound_available = 1;
339: printf ("Sound driver found and configured for %d bits at %d Hz, buffer is %d bytes\n", dspbits, rate, sndbufsize);
340: return 1;
341: }
342:
343: static void flush_sound_buffer(void)
344: {
345: long size = (char *)bufpt - (char *)buffer;
346: if (AFGetTime(ac) > aftime)
347: aftime = AFGetTime(ac);
348: AFPlaySamples(ac, aftime, size, (unsigned char*) buffer);
349: aftime += size / 2;
350: bufpt = buffer;
351: }
352:
353: #elif defined(__mac__)
354:
355: #include <Sound.h>
356:
357: static SndChannelPtr newChannel;
358: static ExtSoundHeader theSndBuffer;
359: static SndCommand theCmd;
360:
361: /* The buffer is too large... */
362: static UWORD buffer0[44100], buffer1[44100], *bufpt;
363:
364: static int have_sound;
365: static int nextbuf=0;
366: static Boolean sFlag=true;
367:
368: int init_sound (void)
369: {
370: if (SndNewChannel(&newChannel, sampledSynth, initMono, NULL))
371: return 0;
372: sndbufsize = 44100;
373: init_sound_table8 ();
374: smplcnt = 0;
375: bufpt = buffer0;
376: sound_available = 1;
377: return 1;
378: }
379:
380: static void flush_sound_buffer(void)
381: {
382: bufpt = buffer0;
383:
384: theSndBuffer.samplePtr = (Ptr)buffer0;
385: theSndBuffer.numChannels = 1;
386: theSndBuffer.sampleRate = 0xac440000;
387: theSndBuffer.encode = extSH;
388: theSndBuffer.numFrames = sndbufsize;
389: theSndBuffer.sampleSize = 8;
390: theCmd.param1 = 0;
391: theCmd.param2 = (long)&theSndBuffer;
392: theCmd.cmd = bufferCmd;
393: SndDoCommand(newChannel, &theCmd, false);
394: }
395:
396: #elif defined(__DOS__)
397:
398: #include "dos-sb.h"
399:
400: void (*SND_Write)(void *buf, unsigned long size); // Pointer to function that plays data on card
401: int dos_dsprate = 1; // 0 for 44100 - 1 for 22050
402: int dos_dspbits = 16;
403:
404: int init_sound (void)
405: {
406: int rate;
407:
408: dspbits = sound_desired_bits;
409: rate = sound_desired_freq;
410: if (rate == 22050)
411: dos_dsprate = 1;
412: else if (rate == 44100)
413: dos_dsprate = 0;
414: else {
415: fprintf(stderr, "Can't use sample rate %d!\n", rate);
416: return 0;
417: }
418:
419: if (SB_DetectInitSound(&dspbits, &dos_dsprate, &sndbufsize));
420: else if (0/*OTHER_CARD_DETECT_ROUTINE*/);
421: else
422: return 0;
423:
424: eventtab[ev_sample].evtime = (long)maxhpos * maxvpos * 50 / rate;
425:
426: if (dspbits == 16) {
427: init_sound_table16 ();
428: eventtab[ev_sample].handler = sample16_handler;
429: } else {
430: init_sound_table8 ();
431: eventtab[ev_sample].handler = sample8_handler;
432: }
433: sound_available = 1;
434: printf ("Sound driver found and configured for %d bits at %d Hz, buffer is %d bytes\n",
435: dspbits, rate, sndbufsize);
436: bufpt = buffer;
437: smplcnt = 0;
438: return 1;
439: }
440:
441: static void flush_sound_buffer(void)
442: {
443: SND_Write(buffer, sndbufsize);
444: bufpt = buffer;
445: }
446:
447: #elif defined(SOLARIS_SOUND)
448:
449: #include <sys/audioio.h>
450:
451: static int sfd;
452: static int have_sound;
453:
454: int init_sound (void)
455: {
456: int rate;
457:
458: struct audio_info sfd_info;
459:
460: sfd = open("/dev/audio", O_WRONLY);
461: have_sound = !(sfd <0);
462: if (!have_sound) {
463: return 0;
464: }
465:
466: rate = sound_desired_freq;
467: dspbits = sound_desired_bits;
468: AUDIO_INITINFO(&sfd_info); /* 44100Hz, mono, 16Bit, linear */
469: sfd_info.play.sample_rate = rate;
470: sfd_info.play.channels = 1;
471: sfd_info.play.precision = dspbits;
472: sfd_info.play.encoding = AUDIO_ENCODING_LINEAR;
473: if (ioctl(sfd, AUDIO_SETINFO, &sfd_info)) {
474: fprintf(stderr, "Can't use sample rate %d with %d bits!\n", rate, bits);
475: return 0;
476: }
477: eventtab[ev_sample].evtime = (long)maxhpos * maxvpos * 50 / rate;
478:
479: if (dspbits == 16) {
480: init_sound_table16 ();
481: eventtab[ev_sample].handler = sample16_handler;
482: } else {
483: init_sound_table8 ();
484: eventtab[ev_sample].handler = sample8_handler;
485: }
486:
487: bufpt = buffer;
488: smplcnt = 0;
489: sound_available = 1;
490: sndbufsize = dspbits/8 * rate;
491: printf ("Sound driver found and configured for %d bits at %d Hz, buffer is %d bytes\n", dspbits, rate, sndbufsize);
492: return 1;
493: }
494:
495: static void flush_sound_buffer(void)
496: {
497: write(sfd, buffer, sndbufsize);
498: bufpt = buffer;
499: }
500:
501:
502: #else
503:
504: int init_sound (void)
505: {
506: produce_sound = 0;
507: return 1;
508: }
509:
510: static void flush_sound_buffer(void)
511: {
512: }
513:
514: #endif
515:
516: void AUDxDAT(int nr, UWORD v)
517: {
518: #ifndef DONT_WANT_SOUND
519: struct audio_channel_data *cdp = audio_channel + nr;
520: cdp->dat = v;
521: if (cdp->state == 0 && !(INTREQR() & (0x80 << nr))) {
522: cdp->state = 2;
523: INTREQ(0x8000 | (0x80 << nr));
524: /* data_written = 2 ???? */
525: eventtab[ev_aud0 + nr].evtime = cycles + cdp->per;
526: eventtab[ev_aud0 + nr].oldcycles = cycles;
527: eventtab[ev_aud0 + nr].active = 1;
528: events_schedule();
529: }
530: #endif
531: }
532:
533: #ifndef DONT_WANT_SOUND
534: static void sample16_handler(void)
535: {
536: int nr;
537: ULONG data = 0;
538:
539: eventtab[ev_sample].evtime += cycles - eventtab[ev_sample].oldcycles;
540: eventtab[ev_sample].oldcycles = cycles;
541:
542: if (produce_sound < 2)
543: return;
544:
545: for (nr = 0; nr < 4; nr++) {
546: if (!(adkcon & (0x11 << nr)))
547: data += sound_table[audio_channel[nr].current_sample][audio_channel[nr].vol];
548: }
549: *bufpt++ = data;
550: if ((char *)bufpt - (char *)buffer >= sndbufsize) {
551: flush_sound_buffer();
552: }
553: }
554:
555: static void sample8_handler(void)
556: {
557: int nr;
558: ULONG data = 0;
559: unsigned char *bp = (unsigned char *)bufpt;
560:
561: eventtab[ev_sample].evtime += cycles - eventtab[ev_sample].oldcycles;
562: eventtab[ev_sample].oldcycles = cycles;
563:
564: if (produce_sound < 2)
565: return;
566:
567: for (nr = 0; nr < 4; nr++) {
568: if (!(adkcon & (0x11 << nr)))
569: data += sound_table[audio_channel[nr].current_sample][audio_channel[nr].vol];
570: }
571: *bp++ = data + 128;
572: bufpt = (UWORD *)bp;
573:
574: if ((char *)bufpt - (char *)buffer >= sndbufsize) {
575: flush_sound_buffer();
576: }
577: }
578:
579: static void audio_handler(int nr)
580: {
581: struct audio_channel_data *cdp = audio_channel + nr;
582:
583: switch (cdp->state) {
584: case 0:
585: fprintf(stderr, "Bug in sound code\n");
586: break;
587:
588: case 1:
589: /* We come here at the first hsync after DMA was turned on. */
590: eventtab[ev_aud0 + nr].evtime += maxhpos;
591: eventtab[ev_aud0 + nr].oldcycles += maxhpos;
592:
593: cdp->state = 5;
594: INTREQ(0x8000 | (0x80 << nr));
595: if (cdp->wlen != 1)
596: cdp->wlen--;
597: cdp->nextdat = chipmem_bank.wget(cdp->pt);
598: cdp->pt += 2;
599: break;
600:
601: case 5:
602: /* We come here at the second hsync after DMA was turned on. */
603: if (produce_sound == 0)
604: cdp->per = 65535;
605:
606: eventtab[ev_aud0 + nr].evtime = cycles + cdp->per;
607: eventtab[ev_aud0 + nr].oldcycles = cycles;
608: cdp->dat = cdp->nextdat;
609: cdp->current_sample = (UBYTE)(cdp->dat >> 8);
610: cdp->state = 2;
611: {
612: int audav = adkcon & (1 << nr);
613: int audap = adkcon & (16 << nr);
614: int napnav = (!audav && !audap) || audav;
615: if (napnav)
616: cdp->data_written = 2;
617: }
618: break;
619:
620: case 2:
621: /* We come here when a 2->3 transition occurs */
622: if (produce_sound == 0)
623: cdp->per = 65535;
624:
625: cdp->current_sample = (UBYTE)(cdp->dat & 0xFF);
626: eventtab[ev_aud0 + nr].evtime = cycles + cdp->per;
627: eventtab[ev_aud0 + nr].oldcycles = cycles;
628:
629: cdp->state = 3;
630:
631: /* Period attachment? */
632: if (adkcon & (0x10 << nr)) {
633: if (cdp->intreq2 && cdp->dmaen)
634: INTREQ(0x8000 | (0x80 << nr));
635: cdp->intreq2 = 0;
636:
637: cdp->dat = cdp->nextdat;
638: if (cdp->dmaen)
639: cdp->data_written = 2;
640: if (nr < 3) {
641: if (cdp->dat == 0)
642: (cdp+1)->per = 65535;
643:
644: else if (cdp->dat < maxhpos/2 && produce_sound < 3)
645: (cdp+1)->per = maxhpos/2;
646: else
647: (cdp+1)->per = cdp->dat;
648: }
649: }
650: break;
651:
652: case 3:
653: /* We come here when a 3->2 transition occurs */
654: if (produce_sound == 0)
655: cdp->per = 65535;
656:
657: eventtab[ev_aud0 + nr].evtime = cycles + cdp->per;
658: eventtab[ev_aud0 + nr].oldcycles = cycles;
659:
660: if ((INTREQR() & (0x80 << nr)) && !cdp->dmaen) {
661: cdp->state = 0;
662: cdp->current_sample = 0;
663: eventtab[ev_aud0 + nr].active = 0;
664: break;
665: } else {
666: int audav = adkcon & (1 << nr);
667: int audap = adkcon & (16 << nr);
668: int napnav = (!audav && !audap) || audav;
669: cdp->state = 2;
670:
671: if ((cdp->intreq2 && cdp->dmaen && napnav)
672: || (napnav && !cdp->dmaen))
673: INTREQ(0x8000 | (0x80 << nr));
674: cdp->intreq2 = 0;
675:
676: cdp->dat = cdp->nextdat;
677: cdp->current_sample = (UBYTE)(cdp->dat >> 8);
678:
679: if (cdp->dmaen && napnav)
680: cdp->data_written = 2;
681:
682: /* Volume attachment? */
683: if (audav) {
684: if (nr < 3)
685: (cdp+1)->vol = cdp->dat;
686: }
687: }
688: break;
689:
690: default:
691: cdp->state = 0;
692: eventtab[ev_aud0 + nr].active = 0;
693: break;
694: }
695: }
696:
697: void aud0_handler(void)
698: {
699: audio_handler(0);
700: }
701: void aud1_handler(void)
702: {
703: audio_handler(1);
704: }
705: void aud2_handler(void)
706: {
707: audio_handler(2);
708: }
709: void aud3_handler(void)
710: {
711: audio_handler(3);
712: }
713: #endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.