More interesting example of my project synth's sound

Drums are from FPC, rest is from 4 instances of the previously mentioned new project, effects are external, and mixing sucks. Turn volume up, it's not mastered.

Valoa kansalle

I had to throw away my old synth, for various reasons. Well, I didn't really throw it away, but it will take ages to make anything sort of a product, 'cos certain things weren't really done the way you would want to do them in a reliable software synthesizer.

The good news though is that for past half a year or so, I've been working on a new codebase, and somewhat different concept. The new synth thingie I call 'Valo' and while it's nowhere near finished, it's got to the point where most things work (well, there's no PWM yet and modwheel/aftertouch/velocity support is missing, and MIDI side lacks quite a few things and...) and it makes sound.

At present it has a completely redesigned oscillators, new filter design (well, if you can call a ladder low-pass new anymore these days) and it does all kinds of fancy stuff like mm.. sawtooth and square waves (well actually triangle as well) and it can do stuff like oscillator sync (properly) and the signal path is so non-linear it's a pain to tune everything 'cos when the signal levels change in one place, everything behind it has to be retuned with proper levels again.. which fortunately is not that many things.

I can't say it sounds clean. With all the non-linearities causing intermodulation distortions and noise here and there making everything slightly unstable, it most certainly does not sound very clean. On the bright side, it can sound approximately as clean as your average analog synth.

Yup, there's sample. Thought you'd like one. Some external effects (Kjaerhus Classic-series Chorus/Delay/Reverb) with pretty simple settings to make it sound less dry as the synth itself doesn't have any add-on effects (I'm not a huge fan of those) and currently only ever outputs mono-signal (that might change I think).

The patch itself is a "little of everything" thing with almost everything in the synth in use, including oscillators in synced mode, pitch envelope driving the slave, some (per-voice) distortion to trash it after filter, and finally both LFOs messing with the signal. No manual knob tweaking done. I'm sure you can tell I'm a very good sound designer.

Audio from some recent code

While I generally liked how my old code sounded, my last iteration of a sound engine had couple of problems. It wasn't nearly as "fat" sounding as I'd hoped, with a bit of too much noise. It'd still sound fine for lower sounds, but the high-end was never quite clear, and both the filter and the oscillators were quite dark and not very aggressive.

Well, I'll be throwing those oscillators away. The filter I might eventually fix. But I've been working with some new oscillators and a new filter, and this sample demonstrates what three triangle waves and a lowpass filter can sound. This is pure virtual analog, no wavetables or anything like that, everything is calculated realtime. Unfortunately, it IS quite heavy on the CPU as of now, so I'll have to see how to optimize it. Eventually that'll happen.

Oh, and I apologize that mp3-compression is somewhat audible.

Virtual Bending

There was some talk about circuit bending on a Finnish music site Mikseri.net, which got me thinking whether I'd have some stuff to try bend at home.

Well, I failed to find anything.

So instead I made some noise with my virtual analog software synth project. The tune, "Virtual Bending" can be found in my less-serious-music-project page in Mikseri.

Filter singing

Who needs oscillators when you have a filter. A bit noisy for now, will have to clean it a bit.

More sound

Since the synth thingie has got some new features, I thought of posting another small sample of what it can sound like in wrong hands. That's a dry sample, with 2 voices unison for the stereo effect.

A little teaser..

So here's a small screenshot of a filter. It's still lacking text labels and I'm not quite sure about the color scheme, but it's using the vector graphics library thingie.

The library itself needs a bit of tweaking before anything using it goes live. Maybe I'll release the library itself as well at some point, I don't know yet.



I was a bit worried about the performance, since it seemed to slow stuff down when redrawing a lot. That could happen for example when another window was moved on top of the thing. What was a bit strange though, was this would typically only happen after a while...

I was already going to write some bitmap caching logic to avoid doing the actual drawing unless something really changed in the window. Then my eyes caught something missing: I was leaking resources in my painting routine. Single line of code to fix that bug. Now it runs pretty nice just redrawing everything on the fly.

Subdivision made visible

I'm currently working on stroking, and trying to come up with a decent algorithm for that stuff. The big problem here isn't really how to code stuff, but rather what things should look like.

Anyway, in order to visualize some problems for myself, I draw a stroke around a stroke. Then I got the idea that if I modify it a little bit, line segments will become visible, and I kinda liked what the result looked like, as it nicely illustrates the bezier subdivision done.

So in the picture below, there is a cubic bezier, which is subdivided into line segments. Then each of these line segments is made 15 pixels wide, and filled with white. Finally those are stroked with a black outline, which makes each individual segment clearly visible.

Elliptic arcs and some more pron

So far the hardest problem to solve turned out to be how to parametrise arcs. There are three obvious parameters, namely a control triangle of the rational quadratic bezier that is the arc. But how to get a weight for the middle point?

After playing with different parametrisation, I currently have one which gives the middle point the weight of cos(angle/2) where angle is an extra parameter to the function. It happens that when the legs of the control triangle are of equal length, and the angle between them is supplied as angle, one gets an arc of a circle. When the legs aren't of equal length, or the parameter isn't the angle between the legs, one gets an ellipse instead. For zero angle one gets normal non-rational bezier, and for angle pi one gets a straight line. Larger angles give the other side of the ellipse or circle.

Bonus benefit is that when the curve is subdivided in the middle, one doesn't need to track weights for the control points. Just using half the angle will give the proper midpoint weight.

For the typical uses of arcs, there's an extra function which simply makes the guess that the angle between the legs will probably be fine. For stuff like corners of polyline strokes or rectangles this seems to be a reasonable value.

And naturally we have a sample picture:



In the picture you see 3 elliptic arcs, one line and one cubic bezier.

Beziergons

Did I miss the deadline?

Two dimensions for a change

Haven't got much of anything interesting added to the synthesizer thingie during the last few days. Instead, I've actually played around a bit in two dimensions. For a long time I've wanted a simple vector graphics library. A few days ago I started playing with the math. The result is rather boring system based on a couple of simple principles:

1. There is canvas, masks, and paint; paint is applied to canvas through a mask.
2. Geometric primitives (= line paths) work with masks.
3. Colors, gradients, bitmaps, whatever, work with paint.
4. To draw a white triangle, cut a triangle shaped hole in a mask, apply white paint.

The result looks like this (smaller one is screencap, bigger is the same thing magnified):


Now, at this point there isn't even a datatype for a path, so the individual lines in the mask must be drawn separately, but fixing that isn't a huge amount of work (actually probably less than writing this blog post). And I'd expect stuff like beziergons to work before christmas.

Now, what is nice about the design, is that as you see it antializes rather beautifully. It actually draws what you'd get by doing 16x16 naive supersampling and averaging down. Ofcourse all the supersampling is internal to the line drawing function. I'll probably make it 256x256 when I have the extra minute to tweak the algorithm a bit more.

The whole thing is a very basic scanline rasterizer, so the trick really is in the scanlines. Now a scanline rasterizer works by incrementing a counter every time it crosses a line going up, and decrements a counter every time it crosses a line going down. Then you typically fill when you've got either non-zero or odd number in your counter, depending a bit on what you want.

The antialising then is actually quite easy, just a question of putting fractional values in the scanline buffer, and drawing an anti-aliased line. The only important thing then is that the line drawing function makes sure that when one starts from left side of the line, and sums all the pixel values until one has crossed the whole line, the result is exactly one. In a sense, what is being drawn is the finite difference of the edge of an antialised half-plane. And I actually got the idea originally from anti-aliasing audio with BLEPs. Don't ask.

And the best thing? Since integration (and differentiation) are linear operations, one can draw each line independently, and just integrate the scanlines at the end. There aren't really any special cases whatsoever.

Ps. I'm not sure if the above makes any sense. I might consider a better explanation some other day, but I now have to add those beziergons. :)

Sample of what I'm working on

Ok, here's a really quick sample clip of stuff my synthesizer project currently does.

One sound, live playing, a touch of delay but no other effects.

Oh and the player (which hopefully works) is XSPF Web Music Player button version.