![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to i_soorig CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [DOOM] / doom|
Return to i_soorig CVS log | Up to [DOOM] / doom |
1.1 ! root 1: // Emacs style mode select -*- C++ -*- ! 2: //----------------------------------------------------------------------------- ! 3: // ! 4: // $Id:$ ! 5: // ! 6: // Copyright (C) 1993-1996 by id Software, Inc. ! 7: // ! 8: // This program is free software; you can redistribute it and/or ! 9: // modify it under the terms of the GNU General Public License ! 10: // as published by the Free Software Foundation; either version 2 ! 11: // of the License, or (at your option) any later version. ! 12: // ! 13: // This program is distributed in the hope that it will be useful, ! 14: // but WITHOUT ANY WARRANTY; without even the implied warranty of ! 15: // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ! 16: // GNU General Public License for more details. ! 17: // ! 18: // $Log:$ ! 19: // ! 20: // DESCRIPTION: ! 21: // System interface for sound. ! 22: // ! 23: //----------------------------------------------------------------------------- ! 24: ! 25: static const char ! 26: rcsid[] = "$Id: i_unix.c,v 1.5 1997/02/03 22:45:10 b1 Exp $"; ! 27: ! 28: #include <stdio.h> ! 29: #include <stdlib.h> ! 30: #include <stdarg.h> ! 31: ! 32: #include <math.h> ! 33: ! 34: #include <sys/time.h> ! 35: #include <sys/types.h> ! 36: ! 37: #ifndef LINUX ! 38: #include <sys/filio.h> ! 39: #endif ! 40: ! 41: #include <fcntl.h> ! 42: #include <unistd.h> ! 43: #include <sys/ioctl.h> ! 44: ! 45: // Linux voxware output. ! 46: #include <linux/soundcard.h> ! 47: ! 48: // Timer stuff. Experimental. ! 49: #include <time.h> ! 50: #include <signal.h> ! 51: ! 52: #include "z_zone.h" ! 53: ! 54: #include "i_system.h" ! 55: #include "i_sound.h" ! 56: #include "m_argv.h" ! 57: #include "m_misc.h" ! 58: #include "w_wad.h" ! 59: ! 60: #include "doomdef.h" ! 61: ! 62: // UNIX hack, to be removed. ! 63: #ifdef SNDSERV ! 64: // Separate sound server process. ! 65: FILE* sndserver=0; ! 66: char* sndserver_filename = "./sndserver "; ! 67: #elif SNDINTR ! 68: ! 69: // Update all 30 millisecs, approx. 30fps synchronized. ! 70: // Linux resolution is allegedly 10 millisecs, ! 71: // scale is microseconds. ! 72: #define SOUND_INTERVAL 500 ! 73: ! 74: // Get the interrupt. Set duration in millisecs. ! 75: int I_SoundSetTimer( int duration_of_tick ); ! 76: void I_SoundDelTimer( void ); ! 77: #else ! 78: // None? ! 79: #endif ! 80: ! 81: ! 82: // A quick hack to establish a protocol between ! 83: // synchronous mix buffer updates and asynchronous ! 84: // audio writes. Probably redundant with gametic. ! 85: static int flag = 0; ! 86: ! 87: // The number of internal mixing channels, ! 88: // the samples calculated for each mixing step, ! 89: // the size of the 16bit, 2 hardware channel (stereo) ! 90: // mixing buffer, and the samplerate of the raw data. ! 91: ! 92: ! 93: // Needed for calling the actual sound output. ! 94: #define SAMPLECOUNT 512 ! 95: #define NUM_CHANNELS 8 ! 96: // It is 2 for 16bit, and 2 for two channels. ! 97: #define BUFMUL 4 ! 98: #define MIXBUFFERSIZE (SAMPLECOUNT*BUFMUL) ! 99: ! 100: #define SAMPLERATE 11025 // Hz ! 101: #define SAMPLESIZE 2 // 16bit ! 102: ! 103: // The actual lengths of all sound effects. ! 104: int lengths[NUMSFX]; ! 105: ! 106: // The actual output device. ! 107: int audio_fd; ! 108: ! 109: // The global mixing buffer. ! 110: // Basically, samples from all active internal channels ! 111: // are modifed and added, and stored in the buffer ! 112: // that is submitted to the audio device. ! 113: signed short mixbuffer[MIXBUFFERSIZE]; ! 114: ! 115: ! 116: // The channel step amount... ! 117: unsigned int channelstep[NUM_CHANNELS]; ! 118: // ... and a 0.16 bit remainder of last step. ! 119: unsigned int channelstepremainder[NUM_CHANNELS]; ! 120: ! 121: ! 122: // The channel data pointers, start and end. ! 123: unsigned char* channels[NUM_CHANNELS]; ! 124: unsigned char* channelsend[NUM_CHANNELS]; ! 125: ! 126: ! 127: // Time/gametic that the channel started playing, ! 128: // used to determine oldest, which automatically ! 129: // has lowest priority. ! 130: // In case number of active sounds exceeds ! 131: // available channels. ! 132: int channelstart[NUM_CHANNELS]; ! 133: ! 134: // The sound in channel handles, ! 135: // determined on registration, ! 136: // might be used to unregister/stop/modify, ! 137: // currently unused. ! 138: int channelhandles[NUM_CHANNELS]; ! 139: ! 140: // SFX id of the playing sound effect. ! 141: // Used to catch duplicates (like chainsaw). ! 142: int channelids[NUM_CHANNELS]; ! 143: ! 144: // Pitch to stepping lookup, unused. ! 145: int steptable[256]; ! 146: ! 147: // Volume lookups. ! 148: int vol_lookup[128*256]; ! 149: ! 150: // Hardware left and right channel volume lookup. ! 151: int* channelleftvol_lookup[NUM_CHANNELS]; ! 152: int* channelrightvol_lookup[NUM_CHANNELS]; ! 153: ! 154: ! 155: ! 156: ! 157: // ! 158: // Safe ioctl, convenience. ! 159: // ! 160: void ! 161: myioctl ! 162: ( int fd, ! 163: int command, ! 164: int* arg ) ! 165: { ! 166: int rc; ! 167: extern int errno; ! 168: ! 169: rc = ioctl(fd, command, arg); ! 170: if (rc < 0) ! 171: { ! 172: fprintf(stderr, "ioctl(dsp,%d,arg) failed\n", command); ! 173: fprintf(stderr, "errno=%d\n", errno); ! 174: exit(-1); ! 175: } ! 176: } ! 177: ! 178: ! 179: ! 180: ! 181: ! 182: // ! 183: // This function loads the sound data from the WAD lump, ! 184: // for single sound. ! 185: // ! 186: void* ! 187: getsfx ! 188: ( char* sfxname, ! 189: int* len ) ! 190: { ! 191: unsigned char* sfx; ! 192: unsigned char* paddedsfx; ! 193: int i; ! 194: int size; ! 195: int paddedsize; ! 196: char name[20]; ! 197: int sfxlump; ! 198: ! 199: ! 200: // Get the sound data from the WAD, allocate lump ! 201: // in zone memory. ! 202: sprintf(name, "ds%s", sfxname); ! 203: ! 204: // Now, there is a severe problem with the ! 205: // sound handling, in it is not (yet/anymore) ! 206: // gamemode aware. That means, sounds from ! 207: // DOOM II will be requested even with DOOM ! 208: // shareware. ! 209: // The sound list is wired into sounds.c, ! 210: // which sets the external variable. ! 211: // I do not do runtime patches to that ! 212: // variable. Instead, we will use a ! 213: // default sound for replacement. ! 214: if ( W_CheckNumForName(name) == -1 ) ! 215: sfxlump = W_GetNumForName("dspistol"); ! 216: else ! 217: sfxlump = W_GetNumForName(name); ! 218: ! 219: size = W_LumpLength( sfxlump ); ! 220: ! 221: // Debug. ! 222: // fprintf( stderr, "." ); ! 223: //fprintf( stderr, " -loading %s (lump %d, %d bytes)\n", ! 224: // sfxname, sfxlump, size ); ! 225: //fflush( stderr ); ! 226: ! 227: sfx = (unsigned char*)W_CacheLumpNum( sfxlump, PU_STATIC ); ! 228: ! 229: // Pads the sound effect out to the mixing buffer size. ! 230: // The original realloc would interfere with zone memory. ! 231: paddedsize = ((size-8 + (SAMPLECOUNT-1)) / SAMPLECOUNT) * SAMPLECOUNT; ! 232: ! 233: // Allocate from zone memory. ! 234: paddedsfx = (unsigned char*)Z_Malloc( paddedsize+8, PU_STATIC, 0 ); ! 235: // ddt: (unsigned char *) realloc(sfx, paddedsize+8); ! 236: // This should interfere with zone memory handling, ! 237: // which does not kick in in the soundserver. ! 238: ! 239: // Now copy and pad. ! 240: memcpy( paddedsfx, sfx, size ); ! 241: for (i=size ; i<paddedsize+8 ; i++) ! 242: paddedsfx[i] = 128; ! 243: ! 244: // Remove the cached lump. ! 245: Z_Free( sfx ); ! 246: ! 247: // Preserve padded length. ! 248: *len = paddedsize; ! 249: ! 250: // Return allocated padded data. ! 251: return (void *) (paddedsfx + 8); ! 252: } ! 253: ! 254: ! 255: ! 256: ! 257: ! 258: // ! 259: // This function adds a sound to the ! 260: // list of currently active sounds, ! 261: // which is maintained as a given number ! 262: // (eight, usually) of internal channels. ! 263: // Returns a handle. ! 264: // ! 265: int ! 266: addsfx ! 267: ( int sfxid, ! 268: int volume, ! 269: int step, ! 270: int seperation ) ! 271: { ! 272: static unsigned short handlenums = 0; ! 273: ! 274: int i; ! 275: int rc = -1; ! 276: ! 277: int oldest = gametic; ! 278: int oldestnum = 0; ! 279: int slot; ! 280: ! 281: int rightvol; ! 282: int leftvol; ! 283: ! 284: // Chainsaw troubles. ! 285: // Play these sound effects only one at a time. ! 286: if ( sfxid == sfx_sawup ! 287: || sfxid == sfx_sawidl ! 288: || sfxid == sfx_sawful ! 289: || sfxid == sfx_sawhit ! 290: || sfxid == sfx_stnmov ! 291: || sfxid == sfx_pistol ) ! 292: { ! 293: // Loop all channels, check. ! 294: for (i=0 ; i<NUM_CHANNELS ; i++) ! 295: { ! 296: // Active, and using the same SFX? ! 297: if ( (channels[i]) ! 298: && (channelids[i] == sfxid) ) ! 299: { ! 300: // Reset. ! 301: channels[i] = 0; ! 302: // We are sure that iff, ! 303: // there will only be one. ! 304: break; ! 305: } ! 306: } ! 307: } ! 308: ! 309: // Loop all channels to find oldest SFX. ! 310: for (i=0; (i<NUM_CHANNELS) && (channels[i]); i++) ! 311: { ! 312: if (channelstart[i] < oldest) ! 313: { ! 314: oldestnum = i; ! 315: oldest = channelstart[i]; ! 316: } ! 317: } ! 318: ! 319: // Tales from the cryptic. ! 320: // If we found a channel, fine. ! 321: // If not, we simply overwrite the first one, 0. ! 322: // Probably only happens at startup. ! 323: if (i == NUM_CHANNELS) ! 324: slot = oldestnum; ! 325: else ! 326: slot = i; ! 327: ! 328: // Okay, in the less recent channel, ! 329: // we will handle the new SFX. ! 330: // Set pointer to raw data. ! 331: channels[slot] = (unsigned char *) S_sfx[sfxid].data; ! 332: // Set pointer to end of raw data. ! 333: channelsend[slot] = channels[slot] + lengths[sfxid]; ! 334: ! 335: // Reset current handle number, limited to 0..100. ! 336: if (!handlenums) ! 337: handlenums = 100; ! 338: ! 339: // Assign current handle number. ! 340: // Preserved so sounds could be stopped (unused). ! 341: channelhandles[slot] = rc = handlenums++; ! 342: ! 343: // Set stepping??? ! 344: // Kinda getting the impression this is never used. ! 345: channelstep[slot] = step; ! 346: // ??? ! 347: channelstepremainder[slot] = 0; ! 348: // Should be gametic, I presume. ! 349: channelstart[slot] = gametic; ! 350: ! 351: // Separation, that is, orientation/stereo. ! 352: // range is: 1 - 256 ! 353: seperation += 1; ! 354: ! 355: // Per left/right channel. ! 356: // x^2 seperation, ! 357: // adjust volume properly. ! 358: leftvol = ! 359: volume - ((volume*seperation*seperation) >> 16); ///(256*256); ! 360: seperation = seperation - 257; ! 361: rightvol = ! 362: volume - ((volume*seperation*seperation) >> 16); ! 363: ! 364: // Sanity check, clamp volume. ! 365: if (rightvol < 0 || rightvol > 127) ! 366: I_Error("rightvol out of bounds"); ! 367: ! 368: if (leftvol < 0 || leftvol > 127) ! 369: I_Error("leftvol out of bounds"); ! 370: ! 371: // Get the proper lookup table piece ! 372: // for this volume level??? ! 373: channelleftvol_lookup[slot] = &vol_lookup[leftvol*256]; ! 374: channelrightvol_lookup[slot] = &vol_lookup[rightvol*256]; ! 375: ! 376: // Preserve sound SFX id, ! 377: // e.g. for avoiding duplicates of chainsaw. ! 378: channelids[slot] = sfxid; ! 379: ! 380: // You tell me. ! 381: return rc; ! 382: } ! 383: ! 384: ! 385: ! 386: ! 387: ! 388: // ! 389: // SFX API ! 390: // Note: this was called by S_Init. ! 391: // However, whatever they did in the ! 392: // old DPMS based DOS version, this ! 393: // were simply dummies in the Linux ! 394: // version. ! 395: // See soundserver initdata(). ! 396: // ! 397: void I_SetChannels() ! 398: { ! 399: // Init internal lookups (raw data, mixing buffer, channels). ! 400: // This function sets up internal lookups used during ! 401: // the mixing process. ! 402: int i; ! 403: int j; ! 404: ! 405: int* steptablemid = steptable + 128; ! 406: ! 407: // Okay, reset internal mixing channels to zero. ! 408: /*for (i=0; i<NUM_CHANNELS; i++) ! 409: { ! 410: channels[i] = 0; ! 411: }*/ ! 412: ! 413: // This table provides step widths for pitch parameters. ! 414: // I fail to see that this is currently used. ! 415: for (i=-128 ; i<128 ; i++) ! 416: steptablemid[i] = (int)(pow(2.0, (i/64.0))*65536.0); ! 417: ! 418: ! 419: // Generates volume lookup tables ! 420: // which also turn the unsigned samples ! 421: // into signed samples. ! 422: for (i=0 ; i<128 ; i++) ! 423: for (j=0 ; j<256 ; j++) ! 424: vol_lookup[i*256+j] = (i*(j-128)*256)/127; ! 425: } ! 426: ! 427: ! 428: void I_SetSfxVolume(int volume) ! 429: { ! 430: // Identical to DOS. ! 431: // Basically, this should propagate ! 432: // the menu/config file setting ! 433: // to the state variable used in ! 434: // the mixing. ! 435: snd_SfxVolume = volume; ! 436: } ! 437: ! 438: // MUSIC API - dummy. Some code from DOS version. ! 439: void I_SetMusicVolume(int volume) ! 440: { ! 441: // Internal state variable. ! 442: snd_MusicVolume = volume; ! 443: // Now set volume on output device. ! 444: // Whatever( snd_MusciVolume ); ! 445: } ! 446: ! 447: ! 448: // ! 449: // Retrieve the raw data lump index ! 450: // for a given SFX name. ! 451: // ! 452: int I_GetSfxLumpNum(sfxinfo_t* sfx) ! 453: { ! 454: char namebuf[9]; ! 455: sprintf(namebuf, "ds%s", sfx->name); ! 456: return W_GetNumForName(namebuf); ! 457: } ! 458: ! 459: // ! 460: // Starting a sound means adding it ! 461: // to the current list of active sounds ! 462: // in the internal channels. ! 463: // As the SFX info struct contains ! 464: // e.g. a pointer to the raw data, ! 465: // it is ignored. ! 466: // As our sound handling does not handle ! 467: // priority, it is ignored. ! 468: // Pitching (that is, increased speed of playback) ! 469: // is set, but currently not used by mixing. ! 470: // ! 471: int ! 472: I_StartSound ! 473: ( int id, ! 474: int vol, ! 475: int sep, ! 476: int pitch, ! 477: int priority ) ! 478: { ! 479: ! 480: // UNUSED ! 481: priority = 0; ! 482: ! 483: #ifdef SNDSERV ! 484: if (sndserver) ! 485: { ! 486: fprintf(sndserver, "p%2.2x%2.2x%2.2x%2.2x\n", id, pitch, vol, sep); ! 487: fflush(sndserver); ! 488: } ! 489: // warning: control reaches end of non-void function. ! 490: return id; ! 491: #else ! 492: // Debug. ! 493: //fprintf( stderr, "starting sound %d", id ); ! 494: ! 495: // Returns a handle (not used). ! 496: id = addsfx( id, vol, steptable[pitch], sep ); ! 497: ! 498: // fprintf( stderr, "/handle is %d\n", id ); ! 499: ! 500: return id; ! 501: #endif ! 502: } ! 503: ! 504: ! 505: ! 506: void I_StopSound (int handle) ! 507: { ! 508: // You need the handle returned by StartSound. ! 509: // Would be looping all channels, ! 510: // tracking down the handle, ! 511: // an setting the channel to zero. ! 512: ! 513: // UNUSED. ! 514: handle = 0; ! 515: } ! 516: ! 517: ! 518: int I_SoundIsPlaying(int handle) ! 519: { ! 520: // Ouch. ! 521: return gametic < handle; ! 522: } ! 523: ! 524: ! 525: ! 526: ! 527: // ! 528: // This function loops all active (internal) sound ! 529: // channels, retrieves a given number of samples ! 530: // from the raw sound data, modifies it according ! 531: // to the current (internal) channel parameters, ! 532: // mixes the per channel samples into the global ! 533: // mixbuffer, clamping it to the allowed range, ! 534: // and sets up everything for transferring the ! 535: // contents of the mixbuffer to the (two) ! 536: // hardware channels (left and right, that is). ! 537: // ! 538: // This function currently supports only 16bit. ! 539: // ! 540: void I_UpdateSound( void ) ! 541: { ! 542: #ifdef SNDINTR ! 543: // Debug. Count buffer misses with interrupt. ! 544: static int misses = 0; ! 545: #endif ! 546: ! 547: ! 548: // Mix current sound data. ! 549: // Data, from raw sound, for right and left. ! 550: register unsigned int sample; ! 551: register int dl; ! 552: register int dr; ! 553: ! 554: // Pointers in global mixbuffer, left, right, end. ! 555: signed short* leftout; ! 556: signed short* rightout; ! 557: signed short* leftend; ! 558: // Step in mixbuffer, left and right, thus two. ! 559: int step; ! 560: ! 561: // Mixing channel index. ! 562: int chan; ! 563: ! 564: // Left and right channel ! 565: // are in global mixbuffer, alternating. ! 566: leftout = mixbuffer; ! 567: rightout = mixbuffer+1; ! 568: step = 2; ! 569: ! 570: // Determine end, for left channel only ! 571: // (right channel is implicit). ! 572: leftend = mixbuffer + SAMPLECOUNT*step; ! 573: ! 574: // Mix sounds into the mixing buffer. ! 575: // Loop over step*SAMPLECOUNT, ! 576: // that is 512 values for two channels. ! 577: while (leftout != leftend) ! 578: { ! 579: // Reset left/right value. ! 580: dl = 0; ! 581: dr = 0; ! 582: ! 583: // Love thy L2 chache - made this a loop. ! 584: // Now more channels could be set at compile time ! 585: // as well. Thus loop those channels. ! 586: for ( chan = 0; chan < NUM_CHANNELS; chan++ ) ! 587: { ! 588: // Check channel, if active. ! 589: if (channels[ chan ]) ! 590: { ! 591: // Get the raw data from the channel. ! 592: sample = *channels[ chan ]; ! 593: // Add left and right part ! 594: // for this channel (sound) ! 595: // to the current data. ! 596: // Adjust volume accordingly. ! 597: dl += channelleftvol_lookup[ chan ][sample]; ! 598: dr += channelrightvol_lookup[ chan ][sample]; ! 599: // Increment index ??? ! 600: channelstepremainder[ chan ] += channelstep[ chan ]; ! 601: // MSB is next sample??? ! 602: channels[ chan ] += channelstepremainder[ chan ] >> 16; ! 603: // Limit to LSB??? ! 604: channelstepremainder[ chan ] &= 65536-1; ! 605: ! 606: // Check whether we are done. ! 607: if (channels[ chan ] >= channelsend[ chan ]) ! 608: channels[ chan ] = 0; ! 609: } ! 610: } ! 611: ! 612: // Clamp to range. Left hardware channel. ! 613: // Has been char instead of short. ! 614: // if (dl > 127) *leftout = 127; ! 615: // else if (dl < -128) *leftout = -128; ! 616: // else *leftout = dl; ! 617: ! 618: if (dl > 0x7fff) ! 619: *leftout = 0x7fff; ! 620: else if (dl < -0x8000) ! 621: *leftout = -0x8000; ! 622: else ! 623: *leftout = dl; ! 624: ! 625: // Same for right hardware channel. ! 626: if (dr > 0x7fff) ! 627: *rightout = 0x7fff; ! 628: else if (dr < -0x8000) ! 629: *rightout = -0x8000; ! 630: else ! 631: *rightout = dr; ! 632: ! 633: // Increment current pointers in mixbuffer. ! 634: leftout += step; ! 635: rightout += step; ! 636: } ! 637: ! 638: #ifdef SNDINTR ! 639: // Debug check. ! 640: if ( flag ) ! 641: { ! 642: misses += flag; ! 643: flag = 0; ! 644: } ! 645: ! 646: if ( misses > 10 ) ! 647: { ! 648: fprintf( stderr, "I_SoundUpdate: missed 10 buffer writes\n"); ! 649: misses = 0; ! 650: } ! 651: ! 652: // Increment flag for update. ! 653: flag++; ! 654: #endif ! 655: } ! 656: ! 657: ! 658: // ! 659: // This would be used to write out the mixbuffer ! 660: // during each game loop update. ! 661: // Updates sound buffer and audio device at runtime. ! 662: // It is called during Timer interrupt with SNDINTR. ! 663: // Mixing now done synchronous, and ! 664: // only output be done asynchronous? ! 665: // ! 666: void ! 667: I_SubmitSound(void) ! 668: { ! 669: // Write it to DSP device. ! 670: write(audio_fd, mixbuffer, SAMPLECOUNT*BUFMUL); ! 671: } ! 672: ! 673: ! 674: ! 675: void ! 676: I_UpdateSoundParams ! 677: ( int handle, ! 678: int vol, ! 679: int sep, ! 680: int pitch) ! 681: { ! 682: // I fail too see that this is used. ! 683: // Would be using the handle to identify ! 684: // on which channel the sound might be active, ! 685: // and resetting the channel parameters. ! 686: ! 687: // UNUSED. ! 688: handle = vol = sep = pitch = 0; ! 689: } ! 690: ! 691: ! 692: ! 693: ! 694: void I_ShutdownSound(void) ! 695: { ! 696: #ifdef SNDSERV ! 697: if (sndserver) ! 698: { ! 699: // Send a "quit" command. ! 700: fprintf(sndserver, "q\n"); ! 701: fflush(sndserver); ! 702: } ! 703: #else ! 704: // Wait till all pending sounds are finished. ! 705: int done = 0; ! 706: int i; ! 707: ! 708: ! 709: // FIXME (below). ! 710: fprintf( stderr, "I_ShutdownSound: NOT finishing pending sounds\n"); ! 711: fflush( stderr ); ! 712: ! 713: while ( !done ) ! 714: { ! 715: for( i=0 ; i<8 && !channels[i] ; i++); ! 716: ! 717: // FIXME. No proper channel output. ! 718: //if (i==8) ! 719: done=1; ! 720: } ! 721: #ifdef SNDINTR ! 722: I_SoundDelTimer(); ! 723: #endif ! 724: ! 725: // Cleaning up -releasing the DSP device. ! 726: close ( audio_fd ); ! 727: #endif ! 728: ! 729: // Done. ! 730: return; ! 731: } ! 732: ! 733: ! 734: ! 735: ! 736: ! 737: ! 738: void ! 739: I_InitSound() ! 740: { ! 741: #ifdef SNDSERV ! 742: char buffer[256]; ! 743: ! 744: if (getenv("DOOMWADDIR")) ! 745: sprintf(buffer, "%s/%s", ! 746: getenv("DOOMWADDIR"), ! 747: sndserver_filename); ! 748: else ! 749: sprintf(buffer, "%s", sndserver_filename); ! 750: ! 751: // start sound process ! 752: if ( !access(buffer, X_OK) ) ! 753: { ! 754: strcat(buffer, " -quiet"); ! 755: sndserver = popen(buffer, "w"); ! 756: } ! 757: else ! 758: fprintf(stderr, "Could not start sound server [%s]\n", buffer); ! 759: #else ! 760: ! 761: int i; ! 762: ! 763: #ifdef SNDINTR ! 764: fprintf( stderr, "I_SoundSetTimer: %d microsecs\n", SOUND_INTERVAL ); ! 765: I_SoundSetTimer( SOUND_INTERVAL ); ! 766: #endif ! 767: ! 768: // Secure and configure sound device first. ! 769: fprintf( stderr, "I_InitSound: "); ! 770: ! 771: audio_fd = open("/dev/dsp", O_WRONLY); ! 772: if (audio_fd<0) ! 773: fprintf(stderr, "Could not open /dev/dsp\n"); ! 774: ! 775: ! 776: i = 11 | (2<<16); ! 777: myioctl(audio_fd, SNDCTL_DSP_SETFRAGMENT, &i); ! 778: myioctl(audio_fd, SNDCTL_DSP_RESET, 0); ! 779: ! 780: i=SAMPLERATE; ! 781: ! 782: myioctl(audio_fd, SNDCTL_DSP_SPEED, &i); ! 783: ! 784: i=1; ! 785: myioctl(audio_fd, SNDCTL_DSP_STEREO, &i); ! 786: ! 787: myioctl(audio_fd, SNDCTL_DSP_GETFMTS, &i); ! 788: ! 789: if (i&=AFMT_S16_LE) ! 790: myioctl(audio_fd, SNDCTL_DSP_SETFMT, &i); ! 791: else ! 792: fprintf(stderr, "Could not play signed 16 data\n"); ! 793: ! 794: fprintf(stderr, " configured audio device\n" ); ! 795: ! 796: ! 797: // Initialize external data (all sounds) at start, keep static. ! 798: fprintf( stderr, "I_InitSound: "); ! 799: ! 800: for (i=1 ; i<NUMSFX ; i++) ! 801: { ! 802: // Alias? Example is the chaingun sound linked to pistol. ! 803: if (!S_sfx[i].link) ! 804: { ! 805: // Load data from WAD file. ! 806: S_sfx[i].data = getsfx( S_sfx[i].name, &lengths[i] ); ! 807: } ! 808: else ! 809: { ! 810: // Previously loaded already? ! 811: S_sfx[i].data = S_sfx[i].link->data; ! 812: lengths[i] = lengths[(S_sfx[i].link - S_sfx)/sizeof(sfxinfo_t)]; ! 813: } ! 814: } ! 815: ! 816: fprintf( stderr, " pre-cached all sound data\n"); ! 817: ! 818: // Now initialize mixbuffer with zero. ! 819: for ( i = 0; i< MIXBUFFERSIZE; i++ ) ! 820: mixbuffer[i] = 0; ! 821: ! 822: // Finished initialization. ! 823: fprintf(stderr, "I_InitSound: sound module ready\n"); ! 824: ! 825: #endif ! 826: } ! 827: ! 828: ! 829: ! 830: ! 831: // ! 832: // MUSIC API. ! 833: // Still no music done. ! 834: // Remains. Dummies. ! 835: // ! 836: void I_InitMusic(void) { } ! 837: void I_ShutdownMusic(void) { } ! 838: ! 839: static int looping=0; ! 840: static int musicdies=-1; ! 841: ! 842: void I_PlaySong(int handle, int looping) ! 843: { ! 844: // UNUSED. ! 845: handle = looping = 0; ! 846: musicdies = gametic + TICRATE*30; ! 847: } ! 848: ! 849: void I_PauseSong (int handle) ! 850: { ! 851: // UNUSED. ! 852: handle = 0; ! 853: } ! 854: ! 855: void I_ResumeSong (int handle) ! 856: { ! 857: // UNUSED. ! 858: handle = 0; ! 859: } ! 860: ! 861: void I_StopSong(int handle) ! 862: { ! 863: // UNUSED. ! 864: handle = 0; ! 865: ! 866: looping = 0; ! 867: musicdies = 0; ! 868: } ! 869: ! 870: void I_UnRegisterSong(int handle) ! 871: { ! 872: // UNUSED. ! 873: handle = 0; ! 874: } ! 875: ! 876: int I_RegisterSong(void* data) ! 877: { ! 878: // UNUSED. ! 879: data = NULL; ! 880: ! 881: return 1; ! 882: } ! 883: ! 884: // Is the song playing? ! 885: int I_QrySongPlaying(int handle) ! 886: { ! 887: // UNUSED. ! 888: handle = 0; ! 889: return looping || musicdies > gametic; ! 890: } ! 891: ! 892: ! 893: ! 894: // ! 895: // Experimental stuff. ! 896: // A Linux timer interrupt, for asynchronous ! 897: // sound output. ! 898: // I ripped this out of the Timer class in ! 899: // our Difference Engine, including a few ! 900: // SUN remains... ! 901: // ! 902: #ifdef sun ! 903: typedef sigset_t tSigSet; ! 904: #else ! 905: typedef int tSigSet; ! 906: #endif ! 907: ! 908: ! 909: // We might use SIGVTALRM and ITIMER_VIRTUAL, if the process ! 910: // time independend timer happens to get lost due to heavy load. ! 911: // SIGALRM and ITIMER_REAL doesn't really work well. ! 912: // There are issues with profiling as well. ! 913: static int /*__itimer_which*/ itimer = ITIMER_REAL; ! 914: ! 915: static int sig = SIGALRM; ! 916: ! 917: // Interrupt handler. ! 918: void I_HandleSoundTimer( int ignore ) ! 919: { ! 920: // Debug. ! 921: //fprintf( stderr, "%c", '+' ); fflush( stderr ); ! 922: ! 923: // Feed sound device if necesary. ! 924: if ( flag ) ! 925: { ! 926: // See I_SubmitSound(). ! 927: // Write it to DSP device. ! 928: write(audio_fd, mixbuffer, SAMPLECOUNT*BUFMUL); ! 929: ! 930: // Reset flag counter. ! 931: flag = 0; ! 932: } ! 933: else ! 934: return; ! 935: ! 936: // UNUSED, but required. ! 937: ignore = 0; ! 938: return; ! 939: } ! 940: ! 941: // Get the interrupt. Set duration in millisecs. ! 942: int I_SoundSetTimer( int duration_of_tick ) ! 943: { ! 944: // Needed for gametick clockwork. ! 945: struct itimerval value; ! 946: struct itimerval ovalue; ! 947: struct sigaction act; ! 948: struct sigaction oact; ! 949: ! 950: int res; ! 951: ! 952: // This sets to SA_ONESHOT and SA_NOMASK, thus we can not use it. ! 953: // signal( _sig, handle_SIG_TICK ); ! 954: ! 955: // Now we have to change this attribute for repeated calls. ! 956: act.sa_handler = I_HandleSoundTimer; ! 957: #ifndef sun ! 958: //ac t.sa_mask = _sig; ! 959: #endif ! 960: act.sa_flags = SA_RESTART; ! 961: ! 962: sigaction( sig, &act, &oact ); ! 963: ! 964: value.it_interval.tv_sec = 0; ! 965: value.it_interval.tv_usec = duration_of_tick; ! 966: value.it_value.tv_sec = 0; ! 967: value.it_value.tv_usec = duration_of_tick; ! 968: ! 969: // Error is -1. ! 970: res = setitimer( itimer, &value, &ovalue ); ! 971: ! 972: // Debug. ! 973: if ( res == -1 ) ! 974: fprintf( stderr, "I_SoundSetTimer: interrupt n.a.\n"); ! 975: ! 976: return res; ! 977: } ! 978: ! 979: ! 980: // Remove the interrupt. Set duration to zero. ! 981: void I_SoundDelTimer() ! 982: { ! 983: // Debug. ! 984: if ( I_SoundSetTimer( 0 ) == -1) ! 985: fprintf( stderr, "I_SoundDelTimer: failed to remove interrupt. Doh!\n"); ! 986: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.