CupTone 2 improvements in removing/reducing artifacts

Unwanted artifacts are just a part of life when processing audio with digital tools, not just Nebula. Tools like DDMF’s Plugin-Doctor has helped us see these artifacts in a lot more detail, and by default a typical Nebula program will have many different types of them. Most of them tend to be present unless something is specifically done about them. In many cases these artifacts will be something you never notice, and they’re often so low in amplitude that it can be said they don’t even matter. In some cases they definitely do impact things negatively though.

For CupTone 2 I put extra effort into trying to reduce artifacts further than ever before. Disclaimer- That means further than *I* have ever done before. I’m not claiming to be the first person to do any of these improvements, and I don’t know what other Nebula devs are up to as I don’t really follow them. I’m just showing examples of what I’ve done to improve these programs myself. Anyone can look at any plug-in or Nebula program with Plugin-Doctor and see for themselves what they might find, and that has been discussed on various forums for a while now, so it’s no secret. Anyway, I’m going to explain each of the four types of artifacts I focused on, and present some graphs showing some examples.

1. The infamous “low end ripple” – This artifact is caused by abrupt truncation of the impulses in a program. It would even happen with standard convolution (meaning, outside of Nebula), if using impulses sampled through something like a preamp. If the impulses are cut off at a shorter length, without any fadeout carefully applied to them, the end result is going to be a ripple. Here’s an example of a program with a ripple:

Here’s the same program from CupTone 2, but as it appears in the release, without the ripple:

2. The second type of artifacts are visible on the Harmonics graph in Plugin-Doctor. You see it as a bunch of stuff on the graph, anywhere besides where the actual lines/plots for the fundamental and harmonics appear. Anything outside of those lines is unwanted artifacts, and these do occur with non-Nebula plugins frequently. Here’s an example from a program (not one of mine) that shows pretty typical artifact levels for Nebula, unless something is done to bring them down:

You’ll notice that most of it is below 100dB, but if you look near the plot for the fundamental at 1khz, you can see stuff going up to around 60dB. Here’s a closer look at that zoomed in:

Some of my existing releases do show up like this on the graph, because I’ve only recently found ways to lower these specific artifacts, which I think are related to the nature of Nebula’s processing (processing the audio in chunks). Here’s an example from CupTone2, where I’ve significantly lowered these artifacts:

You can see that all of the stuff on this graph besides the fundamental tone at 1khz and the 6 harmonics above it, is well below -100dB, even below -125dB.

Some things to note about this type of artifact- When you load a program into Plugin-Doctor, and using PD’s default settings, you’re seeing a graph generated while the program is being slammed at test tones at an input level of 0dB inside Nebula. This shows you artifacts that are actually louder than what you’ll get during normal use, because you aren’t going to always have your input level at a constant 0dB, and you’re really supposed to avoid ever going all the way up that high anyway. So to get a real idea of the kind of artifact levels you’d have in normal use you’d want to use a lower input level, maybe around at least -10dB. Doing this, even with programs that haven’t been tweaked to lower these artifacts, results in much lower levels, usually well below -100dB.

Another thing to note is that the graph can be a bit visually misleading, because by default it’s showing you a view where the bottom half of the graph is under -100dB, which is well below anything you’re ever going to hear. But when you see it filled up with artifacts (like in the first example), it might lead you to believe that the tested plug-in or Nebula program will give you awful results, even though you may never be able to hear it, even with multiple passes of processing. In other words- it looks worse than it really is because of the scaling of the graph (which compounds the issue of the graph being made using atypical 0dB levels, by default).

So ultimately, these artifacts usually don’t really creep into your audio in any noticeable way, but in extreme cases they can. With a more typical input level going into the CupTone 2 programs, the artifacts are even quieter than the example above, which puts them so low that I consider them entirely insignificant.

3. The infamous “chirp”. This is well known in Nebula, going back years, to the beginning. It can happen with certain programs, usually ones with higher levels of harmonic content. It often happens if you have a transient signal, like a drum hit, that peaks close to 0dB, or in some cases even just going over something like -10dBFS into Nebula. Then you get a sudden unexpected, and often ear piercing “chirp” sound mingled into your audio.

Have you ever think why people of rural areas do not suffer with such kind of a situation cialis women where when a customer goes to the bank, the local banker talks to you in the best possible manner and helps you out certainly without undue wait. It acts by inhibiting cGMP-specific phosphodiesterase type 5 (PDE5), which is responsible for insufficient cGMP level. generic cialis canada increases the cGMP level which smoothens the muscles around the male reproductive organ once the man attains the orgasm. Another way to have good time is planning for dates viagra without prescription uk deeprootsmag.org on each or alternative weekend. Many organizations are getting interested in seeing the power of Storytelling for Organizational Success – particularly in relation to communication, canada tadalafil 10mg influence and leadership excellence.

The cause of this artifact can be seen on the Hammerstein graph of Plugin-Doctor. look at the spikes above 2khz on the harmonic plot here (again this is not one of my programs but some of mine do show this, however I’ve been taking steps to minimize/eliminate this one for years and I think in most cases my programs will not chirp):

Those spikes are what you hear when you hear the chirping. Here’s an example of one of my programs from CupTone2:

Notice how much flatter and smoother the harmonic plots are. Some notes about this artifact: Again, just like with the previous one, Plugin-Doctor is showing you what happens with a signal at 0dB by default. This particular artifact is difficult to always completely remove, but the cases where spikes can still be seen in my own programs are usually with much lower input levels, and when the harmonics themselves have dropped to much lower levels, usually approaching -100dB, at which point the spikes won’t be audible, and even then they aren’t nearly as bad as the example showing them up above.

The fact is that these CupTone 2 programs simply wont “chirp” if you drive them very hot. In fact, I’ve even driven some of these programs OVER 0dB in testing and still didn’t get any horrible results. You still shouldn’t do this, because nothing was sampled above 0dB, so you’re ‘running out of samples’ at that point. You’re going beyond the sampled model and aren’t getting any sampled dynamic behavior beyond 0dB. Still, the point is that these programs won’t pierce your ears if you have a transient go in a little too hot.

4. One last type of ‘artifact’ that I don’t think I’ve ever seen anyone else mention, but I’m sure someone probably has at some point, is a form of noise that can occur on the freq response plot, in the highest frequencies. This only happens with higher sample rates, like 88.2 or 96khz, because it shows up above the nyquist frequencies of sample rates like 44.1 and 48khz. Because this noise is so high frequency you might think it doesn’t really matter, because it’s out of the range of human hearing. Also you might assume it would only get put into your audio signal if your audio signal already included content in those upper frequencies.

But I’ve actually seen cases where this noise gets added to a signal that doesn’t include frequencies that high to begin with. In one case I was processing drums with a program that had this high frequency noise, and the noise got added to the drums at a high enough level that it actually messed with a compressor I had later in the chain by crossing the threshold earlier and triggering intense compression. I was baffled at first, as to why I was getting so much compression, because I could hear that my drums were not at the kind of levels to trigger so much gain reduction. I checked everything out and noticed that when bypassing the Nebula instance, the compression went away. It was a very transparent program, but it was adding ‘invisible’ (inaudible) noise at super high frequencies that was raising the overall levels and triggering more compression down the line. I confirmed it by looking on Voxengo Span and I could see this inaudible noise being added to my drums and it was identical to the appearance of it in the program itself.

Here’s an example of this noise (not my program):

In this example you can also notice the low freq ripple and even the ‘chirp’ at around 5khz. The noise in question is over 20khz. I’ve seen examples where it’s much lower in level, and in those cases it doesn’t seem to become a problem, but when it’s really loud like this it can get into your audio signal at those frequencies, even if your audio doesn’t have content up there already.

Here’s an example of a CupTone 2 program, but this is another case where I’ve been working to deal with this noise, bringing it to inconsequential levels for a few years now, so the vast majority of my programs don’t have this minor issue already:

Not too long ago I looked at preamp/tone style programs as the easiest Nebula programs to make, and also the quickest to finalize. I even said that in the sampling guide I wrote for Sound on Sound magazine several years ago. I still think they’re among the least involved kind of programs to make, but if you just make them using the standard/straight forward process of sampling and deconvolving with NAT, you will get some or all of these artifacts, to various degrees. It takes extra time and work not only to learn how to deal with these things, but to actually do it, and I actually refined some of my personal methods during the creation of CupTone 2.

I think you’ll find that it’s one of the most pristine (meaning super low artifact levels) collections of tone style Nebula programs out there.

Posted by Tim in Uncategorized