Build notes by RayeR ******************** This source package was accomodated to use with latest GCC 4.6.x, DJGPP 2.04 Due to GCC optimalization issues since ver. 4.0.1 I modified global optimization flag from -O3 to -Os (-O1 and higher produced crashing code). It would be better to isolate problem function or file and modify the optimization locally. To build the package just run !DJGPP.BAT under plain DOS or Windows DOS box. When using intel HDA be sure to not have set BLASTER environment variable otherwise it will try initialize SB first. █ ▀▄ ▄▄ ▄▄▄▄▄ ▄▄█▌ ▄▄▄ ▀▄▄▄▄ ██▄▄ ▄▄█▀▀▀▀▀▀██ ▄██▀ ▀▀▄ ▀ ▐█▄ ▀▀█ ▐█ ▀▀ ▐█▀▀▀▀█▄ ▐██ █▌ █▀ █ ▀██ █▌ ▐█ █▌ ▀█▄ ▐██ ██ ▐█ ▀▄▀ ▐█▌ █▌ █▌ ▐█ ▀█▄ ▐██ ▐█▌ ██▄ ██ ▐█ █▌ ▐█▌ ██▄ ▐█▌ ▐█▌ ▀▀██▄▄ ██ ▐█ ▐█ ▐█▌ ▀█▌ ██▌ ▄▄▄▄▄ ▐█▌ ▀██▄ ██ ▐█▌ ▐█ ▐██ █▌ ███▀▀▀▀▀▀▀▀███▄ ▀██ ▐██ █▌ ▐█▌ ██ █ ██ ██ █ ██ ▄▄ ▐█▌ ██ ██ ▐█▌ █▌ ▐█▌ ██ ▄▄ ▐█▌ █ ▐█ ██ ██ ██▌ ██ ██ ▐█ ██ ▄▀ ▀ ██ ▀ █ ▐█▌ ▐█▌ ▄███ ▐█▌ ▄▄██ ██ ██ █▄ ▐█▌ ▐▌ ██ ██ ▄▄████▀ █████████▀ ▄███▄ ▄███▄ ██ ▄██ ██▄ ▄██▀ ▐██ ▄███▀▀ ██▀▀▀ ▄▀ ▀ ██▄ ▄██▀ ▀████▀▀ ▀███▀ ▄▀ ▀████▀▀ Apocalyptic Softwaremixing Soundsystem Version 2.10d "Black Spider's April 2008 Release" with HDA support under the GNU/GPL license DOCUMENTATION ------------- Contents: 1. INTRODUCTION 2. FEATURES 3. HOW TO USE 4. CONFIGURING 5. HISTORY 6. FINAL WORDS --------------- 1. INTRODUCTION --------------- This is version 2.10d of JUDAS Apocalyptic Softwaremixing Soundsystem. System+soundcard code & original (buggy) players by Cadaver. Most bugfixes, additions and quality mixer by Yehar. Intel ICH AC97 and HDA codecs support by Black Spider. JUDAS can be used to create devastating digital virtual music & fx abominations with the most popular soundcards. It is mainly intended for games, demos and musicdisks. JUDAS is exclusively intended to be used with Watcom 32bit flat protected mode DOS programs, with either DOS4GW or any other complatible DOS extender. With DOS4GW soundcard IRQs above 7 don't work, though. Previous versions of JUDAS were blasphemy-ware. This means that: * Use at own risk - authors take no responsibility for anything! * Documentation & attitude aren't "serious" or "professional", if you don't like this then look elsewhere! * Contains strictly non-portable DOS code * Full sources are included * Judas is free, it would be nice though if you include the authors in the credits. * Kutulu will always be watching you * Listen to True Nordic Black Metal while programming, preferably Burzum. Or listen to Supreme Teutonic Power Metal :D This version however (all the HDA codec functions only) is released under the GNU/GPL license. The full text of this license can be found in the file gpl20.txt The HDA code was written after analyzing various HDA linux related sources, the drivers from ALSA project made by Takashi Iwai, the OSS sound system project and others. Although this code is different and pretty unique some similarities especially in the HDA nodes access strategy can be found. That is why I decided to publicly release this version of Judas under the GNU/GPL license. ----------- 2. FEATURES ----------- Soundcards supported: * SOUND BLASTER - 8bit sound - mono - autoinit mode for DSP versions > 2.00 - mixrate up to 22050 Hz * SOUND BLASTER PRO - 8bit sound - mono/stereo - mixrate up to 22050 Hz (stereo) or 44100 Hz (mono) * SOUND BLASTER 16 & GRAVIS ULTRASOUND - 8bit/16bit sound - mono/stereo - mixrate up to 44100 Hz * INTEL ICH AC97 CODEC (and compatibles) - 16bit sound - stereo - mixrate up to 48000 Hz ATTENTION: ---------- >> GRAVIS ULTRASOUND support is slightly more complicated than SB support. Sound must be transferred to the card's DRAM before it's played (it cannot play the DMA buffer directly. GUSMAX could, using the codec chip but as a matter of principle it won't be used!) This transfer uses a very high speed (650 kHz) which slows down the CPU a bit. Using a 16-bit DMA channel helps much. GUS support will work at least with Classic & MAX & PnP. >> INTEL ICH AC97/HDA CODECS are only supported in pure DOS. Under Windows, a SOUND BLASTER compatible device will be detected. If all supported devices SB/GUS/AC97/HDA are present (or emulated) in the system, the configuration procedure will choose the GRAVIS ULTRASOUND (by looking at the ULTRASND enviroment variable) as the best option. When only a SOUND BLASTER compatible card and an AC97/HDA codec is present, the config procedure will always chose the SOUND BLASTER device as default (by looking at the BLASTER enviroment variable). THE AC97/HDA code does not make use of any ISA DMA channel and does not need any IRQ (the AC97/HDA interrupt number is given for debug purposes only). The PCI Bus Master DMA engine is started once at the begining (init procedure) and stopped at the uninit procedure. From the programmer point of view, the AC97/HDA codec should be considered just like an SB comptible music card (it still needs a call to the judas update procedure, preferably at 50 - 70Hz to stay compatible with other supported devices). NOTE : The user may need to run the ichinit.com utility that comes with this package in order to unlock or adjust/decrease the AC97 codec volume under pure DOS. The best way out would be to put ichinit.com in autoexec.bat. Should work (although there is absolutely no guarantee it will ;-) with AC97 integrated on i810/i810E/i810E2/i815/i815E/i815EG/i815EP/i815G/i815P/i820/i820E/ i830MP/i840/i845/i845E/i845G/i845GL/i850/i850E/i860/440MX/E7500/SIS735 and some AMD/nVidia chipsets. High Definition Audio codecs do not require ICHINIT to work properly. In theory all HDA platforms are supported. NOTE: AC97 codecs must support VRA (Variable Rate Audio) in order to change the sample rate to something else than 48000 Hz. >> Judas also has a WAV writer. Fileformats supported: * XMs * MODs * S3Ms * WAVs * Raw samples Software mixer features: * 32 channels (can be increased, if you need more!) * Unlimited amount of samples (dynamically allocated) * Clipping * True channel volume meters Fast mixer: * Optional linear interpolation * It's extremely fast! (read SPEED.DOC) Quality mixer: * 32 bit mixing * Click removal system * Either cubic (Hermite) or linear interpolation * Enough volume levels for even the faintest sounds * Makes Judas the best sounding sound system! (Hi Maz!) High-end audio freaks: Look at JUDASW.GIF and JUVSCPW.GIF for interpolation test results. The plots are spectrum analyses of sampled white noise played at a low frequency. Multitasking compatibility stuff: * Developed almost exclusively in a WIN95 dos box, without problems! * Doesn't use Virtual DMA or any strange shit, just allocates the DMA buffer from conventional memory and everything works fine! * Soundcards work under WINDOWS, providing the sound driver doesn't fuck up. However, playback can take a LOT more time (especially on a GUS) than under pure DOS. Some known problems: - Old WIN3.1 GUS driver causes the machine to lock up if a DOS program uses the GUS. - The WIN95 driver of Avance SB16 clone causes the machine to lock up if a DOS program tries to use 16bit DMA. - Some WIN3.1 SB drivers might not work. * All player/mixer code & sound/music data is locked via the DPMI memory locking functions. Feel free to call judas_update() from your IRQ0 handler (remember to lock your own IRQ code/data though!) * If memory can't be locked (not enough physical memory), the situation will be treated as an out-of-memory error. ------------- 3. HOW TO USE ------------- Here follows an explanation how to compile and link the soundsystem to your programs. Later on all JUDAS functions are explained. * MAKEFILE builds the JUDAS library. Simply run wmake to compile. * You'll need NASM to re-compile the mixing routines in JUDASASM.ASM/JASMDJ.ASM. * MAKEEX.BAT will compile the JUDAS example programs. By default they'll be linked with WDOSX. MAKEJP.BAT and MAKEANAL.BAT compile the example programs separately. * To use JUDAS in your own programs, you must have the header files JUDAS.H, JUDASCFG.H & JUDASERR.H in your work directory. Put the following line in your program: #include "judas.h" When linking, remember to tell the linker to use the JUDAS.LIB file. For example: wlink F massacre N massacre.exe L judas.lib SYS wdosx And now to the functions...but first an explanation of JUDAS error handling. For functions that return a value, 1 is success and 0 is failure (except the JUDAS file functions, they work like those defined in IO.H, e.g failed file open returns -1.) If a function returns failure, you can check the reason from the variable judas_error. Error codes are defined in JUDASERR.H, and there are also text strings for them, so it's easy to print the error. GENERAL FUNCTIONS ----------------- void judas_config(void); This reads the soundcard type, port, IRQ & DMA from the enviroment variables (BLASTER & ULTRASND.) If none of them is found, it tries to detect an Intel ICH AC97 compatible codec by querying the PCI bus. If that fails too, it assumes there is no soundcard. The sound configuration can also be manually set, it consists of these variables (all this shit is defined in JUDAS.H) extern unsigned judascfg_device; extern unsigned judascfg_port; extern unsigned judascfg_irq; extern unsigned judascfg_dma1; extern unsigned judascfg_dma2; /* SB16 high DMA */ Device must be DEV_NOSOUND, DEV_SB, DEV_SBPRO, DEV_SB16 or DEV_GUS. judascfg_dma2 is only needed for SB16. These variables can be changed anytime, for example to let the user try different settings. ATTENTION: In NOSOUND mode samples/modules aren't loaded/played, to conserve memory. There is no "simulated" playing. This will cause problems if you need to synchronize your main program to the music (demos!) But, it's not impossible to overcome this. Simply use a secondary timing method (for example, a counter increased by IRQ0) if in NOSOUND mode. int judas_init(unsigned mixrate, unsigned mixer, unsigned mixmode, int interpolation); Tries to init the soundcard according to the sound configuration. If the soundcard doesn't respond, returns failure. When calling this function for the first time, it must also reserve the DMA buffer & the mixing internal buffers, so it might also fail if there's not enough (physical) memory. If everything is successful, the sound output is started and you can begin to call the judas_update() routine. Mixrate is the number of audio samples produced per second. It is auto- corrected if soundcard doesn't support a certain mixrate. Remember: CPU time usage is directly proportional to the mixrate, as it has to produce more audio data at higher rates! Mixer specifies the mixer used. You can select either QUALITYMIXER or FASTMIXER. If you use quality mixer, you'll get better sound quality, but mixing will take much more CPU time. Quality mixer improvements in comparison to fast mixer: 32 bit mixing, click removal, smooth volume slides, 16 bit interpolation of 8 bit samples, more precise volume, cubic interpolation. A simple guideline: If you are making a demo or a game and want to show off with the amazingly fast gfx, choose fast mixer. If you are making a music disk, choose quality mixer. You can also let the user decide! For a sizelimited intro, Judas is a bit too bloated. Mixmode can be one of these, and is also auto-corrected according to soundcard limitations. Stereo sound takes more processing power, especially if the channels aren't panned to extreme left/right or to middle. 16bitness shouldn't affect the CPU time usage much. Quality mixer won't get any faster even if you use mono sound (lazy code). MONO | EIGHTBIT STEREO | EIGHTBIT MONO | SIXTEENBIT STEREO | SIXTEENBIT With fast mixer, any nonzero value in the interpolation parameter turns interpolation on. It will make the sound MUCH better and takes only 50% more CPU time than normal mixing. Quality mixer always uses interpolation, and the interpolation parameter switches between cubic and linear interpolation. Zero makes it linear, any other value cubic. Here's a table that shows how the mixer and interpolation modes affect CPU time usage when playing a 16-bit test xm on a Pentium/166: IP: off linear cubic quality mixer - 34% 36% fast mixer 13% 19% - If you want to change soundcard, mixer, mixmode, mixrate or anything, just call judas_init() again. There will be one empty DMA buffer played, which means a short pause in the sound. void judas_update(void); This will mix new sound data to the DMA buffer. Must be called 20 or more times per second. This can be done either in the main program or in some interrupt (IRQ0 is good, reprogram the PIT clock to something like 50-70 Hz to reduce the amount of work done at a time. This means smoother CPU time usage. Send also the end-of-interrupt before mixing to allow other interrupts meanwhile, this is especially important for Original Sound Blaster & Ultrasound because they need as fast as possible response to the sound card IRQ.) NOTE: the interval at which you call judas_update() WILL NOT affect music tempo, but if you don't call it often enough the sound gets choppy as the old DMA buffer contents get played again. WEIRD SHIT ALERT: judas_update() has to query either the DMA controller or in case of Ultrasound, the soundcard itself, where the sound is currently playing. If judas_update() is called too often (many hundred times in a second), the hardware gives sometimes wrong positions. There is code to compensate that, but in case that you have a Pentium, clicks may still occur in the sound. To avoid this, it's best to wait for a retrace or do something other time-consuming task in between judas_update() calls. And of course, the easiest thing is, as mentioned above, to program the timer to update the sound. 70 Hz is an absolutely safe calling frequency. void judas_uninit(void); This is the most important function, as it stops the sound and restores the soundcard IRQ vector. Make sure this is called at the end of the program, even if user presses Ctrl-C or Ctrl-Break. This is done by setting up signal handlers: int main(int argc, char **argv) { /* Set judas_uninit() to be called at exit */ atexit(judas_uninit); /* Set signal handlers */ signal(SIGINT, handle_int); signal(SIGBREAK, handle_int); judas_config(); judas_init(); ... } static void handle_int(int a) { exit(0); /* Atexit functions will be called! */ } int judas_songisplaying(void); Returns 1 if a song is currently being played, otherwise returns 0. Use this function if you need to know if the song has reached its end and stopped. int judas_wavwriter_open(char *name); int judas_wavwriter_writesome(int handle); int judas_wavwriter_close(int handle); WAV writer functions. You can use them to convert your songs into WAVs. Instructions: Initialize Judas, load a song, start playing it (do not call judas_update() in any phase), call judas_wavwriter_open() with the WAV file name as the parameter, the function returns a file handle for the opened WAV file, keep calling judas_wavwriter_writesome() with the handle as the parameter until the song is finished (indicated by judas_songisplaying()), call judas_wavwriter_close() with the handle as the parameter to finish the WAV writing process. These functions return -1 on error. SAMPLE & CHANNEL FUNCTIONS -------------------------- SAMPLE *judas_allocsample(int length); This allocates a new sample with the given length of bytes. In normal use you don't need to call this but if you want to play long streams of audio or want to do some strange synthetic abominations this might be for you. If you want to play a long audiostream, you must allocate a suitably long buffer with this function, stuff data into it, start playing and then spy the pos field of the channel structure to know where in the buffer to stuff new data. Actually this is a lot like the DMA buffer updating. I didn't want to make functions for this because I wouldn't need them myself and everyone has their own way to make this. judas_allocsample() also allocates the volume profile of the sample. The volume profile takes about 0.002x memory compared to the sampledata itself. It is used by the realtime volume meter routines. void judas_ipcorrect(SAMPLE *smp); In normal use you really don't need this, but if you have allocated a sample with judas_allocsample(), then each time you change the contents of your sample data, you must call this function. It updates a 3,5K safety buffer directly after the sample data. This is needed because of mixing routine optimizations. Ipcorrect originally meant interpolation-correction, when the optimized routines in fast mixer weren't in use yet. It also calculates the volume profile of the sample, for later use by the realtime volume meter routines. When judas_allocsample() is called, the safety buffer is automatically added to the sample length, and enough memory for the volume profile is allocated, so you don't have to worry about those more. WARNING: You must set the end (and also repeat if you're using looping) fields of the sample structure before calling judas_ipcorrect(), or it won't do anything! void judas_freesample(SAMPLE *smp); Frees a sample, no matter if it's made by yourself, or loaded with some of the functions. You can even free a sample which is running, and no crash! NOTE: you can't obtain the samplepointers used by the music players. This is for everyone's safety. And please don't call this function with some random shit as the sample pointer, it'll just fuck up! void judas_playsample(SAMPLE *smp, unsigned chnum, unsigned frequency, unsigned char volume, unsigned char panning); This function has many parameters, but they're really self-explaining. Channel numbers go from 0 to CHANNELS - 1. Volume must be in range 0 to 64*256. Give the sampling frequency of your sample in the frequency parameter if you want it to be played at the original frequency. IMPORTANT: The music players use channels 0 to MOD_CHANNELS - 1. So if you're playing a 8-channel tune, 8 is the lowest free channel. Playing a sample on a music channel while music is on won't fuck up badly, but you will get strange sounds. void judas_stopsample(unsigned chnum); Stops sound on channel chnum by turning the voicemode to VM_OFF. void judas_preventdistortion(unsigned active_channels); This will set mastervolume on all channels to 256 / active_channels. This will totally prevent clipping distortion, but may cause the sound to be too quiet. Experiment by yourself. void judas_setmastervolume(unsigned chnum, unsigned char mastervol); Sets mastervolume on channel chnum. void judas_setmusicmastervolume(unsigned musicchannels, unsigned char mastervol); Sets mastervolume on channels 0 to musicchannels - 1. void judas_setsfxmastervolume(unsigned musicchannels, unsigned char mastervol); Sets mastervolume on channels musicchannels to CHANNELS - 1, i.e on the channels that are free for sound fx. SAMPLE *judas_loadrawsample(char *name, int repeat, int end, unsigned char voicemode); Loads a raw sample, and sets the repeat, end, and voicemode as you wish. Here the repeat and end aren't pointers, but offsets from sample start. Set end to 0 and it will be automatically set to the end of the sample. SAMPLE *judas_loadwav(char *name); Loads a WAV file. WAVs are always one-shot. Stereo WAVs are converted to mono. The function should be able to skip properly the crap-chunks added by various Windows audio recording programs. In addition, starting from version 2.09f WAV files can also be loaded from a library. The default WAV library the system will check is the file JDSWAV.LIB. Please check jdswav.zip package for more details on how to create such a library. void judas_setwavlib (char *name); Overrides the default library name for WAV files. float judas_getvumeter(unsigned chnum); Estimates and returns the true volume on the specified channel. The range is 0..1, but not 1. The values you get don't depend on master volume or mixer. MUSIC LOADING/PLAYING FUNCTIONS ------------------------------- There are three function sets for XM, MOD and S3M format. Only those you use will be linked to your program. The function behaviour is same in every set. Here are the XM functions listed & explained: int judas_loadxm(char *name); Loads an XM file. May fail because of various things, like file not found, read error, incorrect format or out-of-memory. void judas_freexm(void); Frees an XM file, if one has been loaded. It isn't really necessary to do this, because judas_loadxm() will automatically free the previous XM. This is however a good function for testing purposes: if the heap has been corrupted by the player/mixer routines it will page-fault! (I haven't had a page-fault for many days now...) void judas_playxm(void); void judas_stopxm(void); void judas_forwardxm(void); void judas_rewindxm(void); unsigned char judas_getxmpos(void); unsigned char judas_getxmline(void); unsigned char judas_getxmtick(void); unsigned char judas_getxmchannels(void); char *judas_getxmname(void); Should all explain themselves. You cannot hang the machine by calling the functions before an XM has been loaded! JUDAS IO FUNCTIONS ------------------ int judas_open(char *name); int judas_seek(int handle, int bytes, int whence); int judas_read(int handle, void *buffer, int size); void judas_close(int handle); These work really like the standard IO functions defined in IO.H. The idea of them is following: if you want to implement a datafile system (compressed, maybe) you need only to change these routines. DPMI MEMORY-LOCKING FUNCTIONS ----------------------------- int judas_memlock(void *start, unsigned size); int judas_memunlock(void *start, unsigned size); void *locked_malloc(int size); void locked_free(void *address); void *dos_malloc(int size); void dos_free(void *address); These should be self-explanatory. According to the JUDAS "standard", judas_memlock() & judas_memunlock() return 1 on success and 0 on failure. locked_malloc() and locked_free() function just like the normal malloc() & free() functions, they'll just lock and unlock the memory automatically. locked_malloc() returns NULL either if: * there is not enough memory available * the memory cannot be locked dos_malloc() and dos_free() functions allocate and free low DOS memory For multitasking compatibility, you MUST lock all memory (code, data, variables) touched by your IRQ routines. If you do this, Kutulu will be very very proud of you. OTHER THINGS ------------ In JUDAS.H there are definitions for the config currently used as well as many textstring arrays. They can be used to easily print soundcard & audiomode info, as well as errors. Look at JP.C for a good(?) example. /* * Device, port, IRQ, DMA, mixrate & mixmode currently in use. * Don't change them! */ extern unsigned judas_device; extern unsigned judas_port; extern unsigned judas_irq; extern unsigned judas_dma; extern unsigned judas_mixrate; extern unsigned char judas_mixmode; /* * Mixer names */ extern char *judas_mixername[]; /* * Sound device names */ extern char *judas_devname[]; /* * Mixmode names */ extern char *judas_mixmodename[]; /* * Interpolation mode names */ extern char *judas_ipmodename[]; /* * Error code */ extern int judas_error; /* * Text strings for the error codes */ extern char *judas_errortext[]; /* * Clipping indicator (quality mixer only) indicates the hardest * clipping occurred. 0 = has not clipped, 64 = Very faint clipping, * 128 = half volume wouldn't clip, 255 = 1/4 volume wouldn't clip * Does not give values in range 1..63. */ extern volatile char judas_clipped; -------------- 4. CONFIGURING -------------- In JUDASCFG.H there are a couple of interesting defines. Look at it for an explanation & instructions. ---------- 5. HISTORY ---------- V2.0 - Original release V2.01 - Corrected S3M arpeggio (if zero, must use previous infobyte) - Corrected XXX-fuckup in soundcard enviroment variables - Corrected player bounds checking in Anal Invaders V2.02 - Removed error checking from sample loading in MODs & S3Ms, to make corrupted modules work. In the XM loader I didn't dare to do this, because XMs contain various headers in between sampledata, and if they're not in their correct position...BIG SHIT HAPPENS! - Added a check to MOD loader that loop end must not be beyond sample length. This makes those weird shittunes like DALLAS.MOD work without crashing. - Corrected the spelling of Vintersemestre in the hails section of this document. V2.03 - Added a keyboard handler to Anal Invaders, now it's easier to play! - Added support for empty patterns in XMs - Corrected the "inaudible-bassline-bug" of HERRA.S3M - Corrected volumeslide "both-parameters-nonzero" bug in XMs & MODs V2.04 - Added handling of mono S3Ms and "panning magic" to S3M loader - Added undocumented panning commands to MOD and S3M players, now songs by Khyron will be played correctly! - Corrected S3M vibrato "lose-old-speed-bug" - Removed some checking in S3M loader - Corrected S3M frequency limits - Corrected S3M portamento up & down to use the same previous value - Scaled default pannings by 50% to prevent "earache" - Corrected S3M sample offset command to remember old value - Corrected XM global volume limits - Corrected MOD instrumentnumber/note alone bug - XM toneportamento must not change the instrument/samplenumber (a very stupid bug!) V2.04y - Added selectable quality mixer and made required changes to the example programs - Added simple file writer V2.05 - Corrected behaviour of retrig command in both XMs & MODs. Now retrig in XMs behaves just like in FT2 and in MODs like in Cubic Player (confusing!!!) After doing this, Cadaver is on the verge of total mind meltdown... - In MODs, a notedelay without a note mustn't play anything. - There might be 256 patterns in a mod, so mt_patterns variable must be bigger than 8 bits. - If GUS DMA-transfer cache fills up (some IRQ missed maybe) then cache is cleared manually. Sometimes sound stuck under WIN95, hopefully this corrects it! - Made JPLAY's default volume louder - Added some little things to the documentation - December has begun, cold frostvoid everywhere... - This will probably be the last version of Judas of which you can get Cadaver's version also. V2.06y - Corrected XM & MOD handling of two pattern breaks on the same row. The problem still exists in the S3M player, because the channels should be sorted somehow accordingly to the default panning, and that's just too much shit for us! - Corrected XM, MOD & S3M track sine vibrato phase. (Hi Dagoon!) - XM & S3M note cut now works! - Made song end autodetection & looping control. Now you can set how many times the song plays before it stops by itself! Infinite looping is also possible. - Killed a bug that caused S3M player to sometimes crash at song end. - Increased the number of volume levels. (Audible with Quality Mixer only!) If you have used the sample playing functions of older versions of Judas, and want to use the latest version of Judas in your program, just multiply the volumes that go to judas_playsample() by 256. - Renamed JPLAY to JP to make it faster to type. Retrain your fingers! - Made the clip removing routines detect and handle sudden VM_OFFs! Now S3Ms with noteoffs sound smoother. - Added channel volume meters. Don't worry! They won't slow down the mixing at all when you don't use them! - Rewrote the file writer. Now it writes WAV files! - Made Judas WATCOM 11.0 compatible. (Structure packing was the problem) - Optimized mixing routines a bit. - Added quality mixer clipping indicator. - Added song rewinding and forwarding. - Released at the Abduction'98 demoparty!!! V2.07a - Added pure DOS support for INTEL ICH0/ICH/ICH2/ICH3 and compatible AC97 integrated audio codecs (judasac.h and judasac.inc defines). - Added low DOS memory functions dos_malloc() and dos_free() - Advanced error tracking and debug functions for AC97 support code located in judas.c file. - Added a separate ichinit DOS utility for AC97 codecs. (Black Spider's February 2003 release). V2.07y - Improved pure DOS support for INTEL ICH0/ICH/ICH2/ICH3 and compatible AC97 integrated audio codecs (judasac.h and judasac.inc defines). - Added ICH4 controller support. - Example programs now use the WDOSX DOS extender instead of PMODE/W (Black Spider's March 2003 release). V2.08y - Improved pure DOS support for INTEL ICH4 AC97 integrated audio codecs. (Black Spider's March 2003 release). V2.09a - Added support for SIS7012 - now it works :) V2.09b - Corrected ICH4 and above chips support - now it works :) V2.09c - Dev version (all tasm code converted to nasm) V2.09d - Dev version with full support for WATCOM C++ and DJGPP near pointers V2.09e - All AC97 audio devices now use memory mapped IO if available V2.09f - WAV library builder added to JUDAS. See JDSWAV.ZIP package for details v2.10a - High Definition Audio codecs support added - supported up to ICH10 (!) v2.10b - judas_setwavlib function added v2.10c - High Definition Audio codecs support update for intel 5 and 6 series test by RayeR v2.10d - High Definition Audio codecs support update for intel 7 series test by RayeR -------------- 6. FINAL WORDS -------------- JUDAS was written because Cadaver got bored of digital sound systems which were full of restrictions (register and you'll get sound fx support!), didn't interpolate, were made in Pascal or refused to work if they ran out of Ultrasound memory. It was programmed in the realms of northern icy void from March 1997 onwards. Hail from Cadaver to these supreme artists: Impaled Nazarene, Mustan Kuun Lapset, Vintersemestre, Horna, Troll, Burzum, Immortal, Mercyful Fate. Hail to all perverts who know us! email Cadaver: loorni@student.oulu.fi Cadaver's homepage: http://www.student.oulu.fi/~loorni email Yehar: ollinie@freenet.hut.fi Absorb free ambient techno: http://www.sublevel3.org NOTE: Judas is developed as a sound system, not as a player. So, don't ask us to program Cubic-Player-like fileselectors or such. It's YOUR job, right? :) ------------------------------------------------------------------------------ NOTE: Judas sound system for DOS is no longer developed. However this sound engine is now integrated in the BME package, which is available at Cadaver's web site. The last original 2.06y version of Judas for DOS was released in 1998. This version (2.10b - Black Spider's release) only adds AC97/HDA codecs support for the DOS version of Judas sound system. There are also a few docs changes. Just enough to explain AC97/HDA behaviour. Many thanks to Matthias Goeke for providing the ICH5 as well as the HDA mainboard for testing purposes. Greetz to all those who release their coding stuff with source code. Hail to the ones who know me, and of coz to Cadaver and Yehar for makeing such a good DOS sound engine. email to Piotr Ulaszewski (aka BSpider) for AC97/HDA support problems: (don't forget to specify the type of hardware you use :-) piotrkn22@poczta.onet.pl http://www.piotrkn22.republika.pl