emusonacid! legacy

illinformed: Only yeasterday i've the chance to test the samples from "analoguesque" they're great... next month i'll be buying their disk set (if i manage to get that spare money).. thank man

also in the files there were waveforms cut and loop for sines, saw, etc... so it's a big head start in my waveform-pet-project :)

but the idea of tooling my emu with loops of banks/patches has grown on me :)) does anyone knowns of more sites like the analoguesque?

I really can't afford the orbit/phat sessions cards (they cost as much as a second hand synth) and haven't got a cd-rom in my sampler (or scsi card to transfer the cd-rom to the sampler... but anyway sample cds are too expensive)


regards,


JD

A little addition. Because of a post earlier I started to investigate 'The Emulator Production Set' CD Rom that I got free with my sampler.

In the 'Tools' folder there's a bank called "SD's Tool Box". It's a kit that allows you to create synth sounds with a handfull of sinewaves. By using a midi controllers it allows you to mix, add and modulate the waves. My favourite Preset has to be 'Wavemaker 6'. I'm going to put a few of my own waves in and experiment.

Funny enough, I just thought about this two days ago. I own a JX-8P which CAN do decent sounds, but really is PITA to program (don't have the programmer...) But they don't even use sine waves in there, but have a sawtooth, a square and a pulse as basic functions. It should be quite nice to combine two of these and use the EOS capabilities to create old analog sounds...

If you are a little into math, there might be a link that might help. Look for the program SCIlab (I think it's at www.inria.fr or so). This is a math tool, but afaik, it can write wav-files. This would allow you to create wav-files with given waveforms that you could use for a more efficient additive synthesis (on my JX8p, you can only swith the octave of the basic wave...). The pro sister MATlab can write waves, but is F*ckin expensive...

aXel

OK, I tried it out and SciLab seems to do the job... I copy some part of the documentation from scilab to show how it works...

wavwrite(y,Fs,bits,wavfile)

with

y : real vector or matrix with entries in [-1,1].
wavfile : string (The .wav extension is appended if no extension is given)
Fs : integer, frequency sampling in Hz.
bits : integer, number of bits in the encoding.
method : string , 'mu' (default) or 'linear' , encoding method.

So you should be able to design any waveform that you like by assigning the values to a vector and then saving it as a WAV-file...

As SciLab is freeware, you get this possbility at no costs (except for the learning curve!)

The more I think about it, the more I get the idea that One could do a lot of freaky thingy with scilab... (Don't forget, you have LOADS of signal theory with the packet!

aXel

Oh yeah: another thing... Imagine how short most of these wav-forms could be... Just think of a sample set of

square with different ratio
sawtooth
sine
some 'overdriven' sine
some rather 'pulsy' sine-type waves

all of these waves should be sufficiently well described when using lets say 3 or four frequency periods. This should sum up as something like 1/2 s of samples for quite a lot of samples for the whole keyboard range for one sample type. This means you should be able to get HUGE banks of real analog sounding stuff onto one diskette...


Here's a little file that should do the job (was too lazy for the trimming to shortest useful length, but that should be no major deal


// BASEWAVS.sci
// First, increase the size of memory used for scilab (should be sth. like 80MB now)
stacksize(10000000)


// Freqency of the samples
Freq = 44100;

t = 0:Freq-1; // a counter from zero to Freq-1
t = t'/Freq; // normalized to one second


// Create a basic set of sine waves
sin_10 = sin(t*2*%pi * 10);
sin_20 = sin(t*2*%pi * 20);
sin_50 = sin(t*2*%pi * 50);
sin_100 = sin(t*2*%pi * 100);
sin_200 = sin(t*2*%pi * 200);
sin_500 = sin(t*2*%pi * 500);
sin_1000 = sin(t*2*%pi * 1000);
sin_2000 = sin(t*2*%pi * 2000);
sin_5000 = sin(t*2*%pi * 5000);
sin_10000 = sin(t*2*%pi * 10000);


// creat a basic set of cosine waves
cos_10 = cos(t*2*%pi * 10);
cos_20 = cos(t*2*%pi * 20);
cos_50 = cos(t*2*%pi * 50);
cos_100 = cos(t*2*%pi * 100);
cos_200 = cos(t*2*%pi * 200);
cos_500 = cos(t*2*%pi * 500);
cos_1000 = cos(t*2*%pi * 1000);
cos_2000 = cos(t*2*%pi * 2000);
cos_5000 = cos(t*2*%pi * 5000);
cos_10000 = cos(t*2*%pi * 10000);



// From that calculate a basic set of square waves
sqr_10 = sign(sin_10);
sqr_20 = sign(sin_20);
sqr_50 = sign(sin_50);
sqr_100 = sign(sin_100);
sqr_200 = sign(sin_200);
sqr_500 = sign(sin_500);
sqr_1000 = sign(sin_1000);
sqr_2000 = sign(sin_2000);
sqr_5000 = sign(sin_5000);
sqr_10000 = sign(sin_10000);


//... and the timeshifted ones
ssqr_10 = sign(cos_10);
ssqr_20 = sign(cos_20);
ssqr_50 = sign(cos_50);
ssqr_100 = sign(cos_100);
ssqr_200 = sign(cos_200);
ssqr_500 = sign(cos_500);
ssqr_1000 = sign(cos_1000);
ssqr_2000 = sign(cos_2000);
ssqr_5000 = sign(cos_5000);
ssqr_10000 = sign(cos_10000);


// create a set of triangular waves
tri_10 = asin(sin_10)*2/%pi;
tri_20 = asin(sin_20)*2/%pi;
tri_50 = asin(sin_50)*2/%pi;
tri_100 = asin(sin_100)*2/%pi;
tri_200 = asin(sin_200)*2/%pi;
tri_500 = asin(sin_500)*2/%pi;
tri_1000 = asin(sin_1000)*2/%pi;
tri_2000 = asin(sin_2000)*2/%pi;
tri_5000 = asin(sin_5000)*2/%pi;
tri_10000 = asin(sin_10000)*2/%pi;



// and a set of sawtooth --- THEY HAVE DOUBLE FREQ!!!
saw_20 = tri_10.*ssqr_10;
saw_40 = tri_20.*ssqr_20;
saw_100 = tri_50.*ssqr_50;
saw_200 = tri_100.*ssqr_100;
saw_400 = tri_200.*ssqr_200;
saw_1000 = tri_500.*ssqr_500;
saw_2000 = tri_1000.*ssqr_1000;
saw_4000 = tri_2000.*ssqr_2000;
saw_10000 = tri_5000.*ssqr_5000;


// save all wavs
wavwrite(sin_10,Freq,16,'sin_10');
wavwrite(sin_20,Freq,16,'sin_20');
wavwrite(sin_50,Freq,16,'sin_50');
wavwrite(sin_100,Freq,16,'sin_100');
wavwrite(sin_200,Freq,16,'sin_200');
wavwrite(sin_500,Freq,16,'sin_500');
wavwrite(sin_1000,Freq,16,'sin_1000');
wavwrite(sin_2000,Freq,16,'sin_2000');
wavwrite(sin_5000,Freq,16,'sin_5000');
wavwrite(sin_10000,Freq,16,'sin10000');

wavwrite(sqr_10,Freq,16,'sqr_10');
wavwrite(sqr_20,Freq,16,'sqr_20');
wavwrite(sqr_50,Freq,16,'sqr_50');
wavwrite(sqr_100,Freq,16,'sqr_100');
wavwrite(sqr_200,Freq,16,'sqr_200');
wavwrite(sqr_500,Freq,16,'sqr_500');
wavwrite(sqr_1000,Freq,16,'sqr_1000');
wavwrite(sqr_2000,Freq,16,'sqr_2000');
wavwrite(sqr_5000,Freq,16,'sqr_5000');
wavwrite(sqr_10000,Freq,16,'sqr10000');

wavwrite(tri_10,Freq,16,'tri_10');
wavwrite(tri_20,Freq,16,'tri_20');
wavwrite(tri_50,Freq,16,'tri_50');
wavwrite(tri_100,Freq,16,'tri_100');
wavwrite(tri_200,Freq,16,'tri_200');
wavwrite(tri_500,Freq,16,'tri_500');
wavwrite(tri_1000,Freq,16,'tri_1000');
wavwrite(tri_2000,Freq,16,'tri_2000');
wavwrite(tri_5000,Freq,16,'tri_5000');
wavwrite(tri_10000,Freq,16,'tri10000');

wavwrite(saw_20,Freq,16,'saw_20');
wavwrite(saw_40,Freq,16,'saw_50');
wavwrite(saw_100,Freq,16,'saw_100');
wavwrite(saw_200,Freq,16,'saw_200');
wavwrite(saw_400,Freq,16,'saw_500');
wavwrite(saw_1000,Freq,16,'saw_1000');
wavwrite(saw_2000,Freq,16,'saw_2000');
wavwrite(saw_4000,Freq,16,'saw_5000');
wavwrite(saw_10000,Freq,16,'saw10000');







Now you should send me your SPECIAL patches

aXel

A big thankyou to volltreffer for finding this little beauty and for posting up some examples to get me going. I'm a bit of a cut and paste merchant and that'll really help me out. I've only been skimming through but this looks like it's exactly what I've been looking for. I think it will be fun to include some 'For...Next' statements to get some gradual changes to the waves.

Aren't the cords meant to do the remaining synthesis??? That's what I thought they were for, but I have to admit that I did use my machine only as kinda CD-Rompler (never did anything myself).

I hope I will get help on my future questions, too... That's just one of the things were I can help, but not really with the EMU...



aXel

BTW: the correct link should be www.scilab.org now...

volltreffer wrote:Aren't the cords meant to do the remaining synthesis???

You're absolutely right however I was thinking more along the lines of crossfading between waves. I quite like the idea of morphing from one waveform to another. It would be possible to produce 128 gradually changing waves in Scilab then set up a preset that realtime crossfaded between these waves. You could still add a little extra spice by some intricate cord programming too. It hurts my head imagining all the different scenarios that can take place within the emu.

Andrew

Instead of using Scilab, have you considered sampling the test tones that the Ultra produces (Sine, Sawtooth, Square, Triangle) Waves.

Seems easier.

i never thought this thread would span so many post

i've kept doing some presets in the emu, based only on simple (and not so simple) waveforms .

the possibilites are endeless are the emu can really kick some serious butt on emulation most analog-type type synthesis this way

at the moment i'm a bit limited since i dont own a scsi card to transfer stuff from the pc... using a floppy would be enough but my emu crashes a lot while reading pc formated disks

from time to time i come across simple waveform files, most already cut and looped wich helps alot this process.

i think other synth technologyes like wavetables, adictive, etc can be partly emulated but haven't tryed... to be honest i understand a little bit of analog syntesis but not much about fm, addictive and other wich employ a lot of maths...

[[[]]]

just my opinion

jo

My e6400 ultra came with a floppy containing some grand piano presets. If you've got this, browse samples for the 'vonstruble pulse'. The sample contains positive, and negative ramps (for saw waves), constant values, positive and negative (for square waves), so can be used as a construction kit for 'perfect' waveforms (with much copying and pasting!). Looping 8 or more cycles usually does the trick. Any less, and you hear the loop points more than the waveform!
As for the sine, i just recorded the sine test signal to dat, then back into the emu. By using some high quality, phase linear bandpass filtering you can 'force' the sine to be near enough perfect.

If you want some 'public domain' whitenoise, force a sample with nothing plugged into the inputs. The sampler picks up the background radiation left over from the beginning of the universe (which is nice). By normalising to 0dB using 'gain' you should have a decent noise sample.
Its not perfect whitenoise, and its hard to loop, but should be 'noisy' enough for your purpose.

Hey everyone!

if any1 is still interested in this sorta thing I found an easy solution - there is a VST Synth called Z3ta. The synth sounds pretty crap like all vsts do, but it based on analog waveforms. So it comes with a bank full of short perfectly sampled at 16 bit mono 44100 waveforms. And there are lotta free banks on the Web, so you don't need to buy the VST, just find a bank file, go to the samples directory and here we go ... you got the whole bunch of samples...

good luck!

deni:s
insects@mail.ru

what would be intressting would be if someone pullout some of the wavetables from the waldorf wave/xt/mW1 or 2, as a wave.. then build up the patce like a wavetable synth. loop a cycle at the time. Then be able to in realtime slide through the wavetable. it should be possible?+

rgs
Egil