White Noise 32-bit/64-bit Engine Test

BTW, I think it's safe to say that "-Inf." is "absolute silence" and completely inaudible, except to the Homeopathic Medicine true believers.

ORIGINAL: dcastle

If you have the time, would you run the same test with 16-24 tracks of white noise run at various levels.

• I created a 32-bit floating point WAV with 60 seconds of 0db white noise.
  
• I imported this into 16 tracks of a SONAR 5 project.
  
• I randomly adjusted the track faders from +4.8db to -48db
  
• I had to lower the Master fader by -18db to keep the output from clipping
  
• I compared in Sound Forge 8.0 --- the RMS difference is -148db

There is no glitch in this output, and the difference normalized to 0db looks and sounds like white noise.

Let's put something into perspective here:

• The theoretical resolution of a 16-bit WAV file is -96db
  
• The theoretical resolution of a theoretically perfect mic preamp is -130db
  
• The theoretical resolution of a 24-bit integer WAV file is -144db
  
• The theoretical resolution of a 32-bit integer WAV file is -192db

In this context, the 32-bit audio engine has less than 1/2 the noise of a theoretically perfect mic preamp when mixing 16 tracks of 0db white noise with various fader settings.

Let me remind you that 140-160db is approximately the loudness of a space rocket launch compared to the threshold of hearing. Both are ridiculously good, but the 64-bit audio engine appears to be -148db better, which is quite a bit less than 20-40%

Regards,
David

BTW, Did you know there is a 64-bit floating point WAV format?

BTW, Did you know there is a 64-bit floating point WAV format?

Yes SONAR 5.01 already supports exporting to this format :-)

ORIGINAL: Noel Borthwick [Cakewalk]

Yes we figured it would take some of the guesswork and confusion out of the picture if you could export natively to 64 bit resolution keeping all the bits intact. There are very few apps that will support reading this format today though.

Now my brain hurts!

BTW, Did you know there is a 64-bit floating point WAV format?

ORIGINAL: dcastle

Greetings,

Mod Bod wrote: I still think a white noise test will be the ultimate test.

• I created a 60 second long -12db white noise sample in Sound Forge 8.0 Tools-->Synthesis...
  
• Imported into SONAR 5 (no effects, no fader moves, no pans, nothing)
  
• Exported with 32-bit audio engine [WHITE32.wav]
  
• Exported with 64-bit audio engine [WHITE64.wav]
  
• Compare in Sound Forge 8.0 --- difference is "-Inf."

I think this shows that it is not a fundamental problem with the audio engine, but there is still something funny with that 11mS -50db glitch at 1/10th of a second. Next I will try adding effects, etc.

Regards,
David

BTW, I think it's safe to say that "-Inf." is "absolute silence" and completely inaudible, except to the Homeopathic Medicine true believers.

Running white noise through an RMS meter yields very low values, something like the crest value is on the order of 8:1 or something like that. Please try the test again with a 0 dB 1 kHz sinewave.

• After all the grief about recording white noise, I decided to do something similar but slightly more complex, so I created a 32-bit floating point WAV with 30 seconds of 0db DTMF tones for "1234567890ABCDEF#*"
  
• I imported this into 16 tracks of a SONAR 5 project.
  
• I randomly adjusted the track faders from +4.8db to -48db
  
• I had to lower the Master fader by -18db to keep the output from clipping
  
• I exported one file with the SONAR 5 32-bit audio engine
  
• I exported another file with the SONAR 5 double-precision 64-bit audio engine
  
• I compared them in Sound Forge 8.0 --- the RMS difference is -149db (1db lower than the white noise test)

	// Fill 2 buffers with noise
 	fillNoise( src1pcm, BUFSIZE );
 	fillNoise( src2pcm, BUFSIZE );
 
 	// Convert to floating point
 	pcmToFloat<float>( src1, src1pcm, BUFSIZE );
 	pcmToFloat<float>( src2, src2pcm, BUFSIZE );
 
 	// Compute (g1*S1+g2*S2-g1*S1)/g2
 	memset( dst, 0, sizeof(dst) );
 	mix<float>( dst, src1, BUFSIZE, gain1 );
 	mix<float>( dst, src2, BUFSIZE, gain2 );
 	mix<float>( dst, src1, BUFSIZE, -gain1 );
 	scale<float>( dst, BUFSIZE, 1.0 / gain2 );
 
 	// Convert answer back to PCM
 	floatToPcm<float>( dst, BUFSIZE );
 
 	// Compare ‘dst’ samples to ‘src2’, count errors
 	. . .

ORIGINAL: Ron Kuper [Cakewalk]

I'm giving a talk today at AES, and this exact question is covered in it.

I wrote a test program that mixes buffers of (24-bit PCM) noise using 32-bit floats and 64-bit doubles. The mix was then converted back to 24-bit and the results were compared to what the expected result ought to be. The verdict is that using 32-bit floats to mix 24-bit data introduces at most 6dB of error more than 25% of the time.

The program simulates what happens if you mix multiple audio streams using different gains, and scale the result, as shown below
( g1*[S1] + g2*[S2 ] – g1*[S1 ] ) / g2
You would expect the 1st and 3rd streams to cancel each other out, leaving the result of mix to be [S2 ].

The test code looks roughly like this:

	// Fill 2 buffers with noise
 	fillNoise( src1pcm, BUFSIZE );
 	fillNoise( src2pcm, BUFSIZE );
 
 	// Convert to floating point
 	pcmToFloat<float>( src1, src1pcm, BUFSIZE );
 	pcmToFloat<float>( src2, src2pcm, BUFSIZE );
 
 	// Compute (g1*S1+g2*S2-g1*S1)/g2
 	memset( dst, 0, sizeof(dst) );
 	mix<float>( dst, src1, BUFSIZE, gain1 );
 	mix<float>( dst, src2, BUFSIZE, gain2 );
 	mix<float>( dst, src1, BUFSIZE, -gain1 );
 	scale<float>( dst, BUFSIZE, 1.0 / gain2 );
 
 	// Convert answer back to PCM
 	floatToPcm<float>( dst, BUFSIZE );
 
 	// Compare ‘dst’ samples to ‘src2’, count errors
 	. . .

For nearly all values of gain1 and gain2 there is error.

More details to come when we post the slides from my talk. I will also post the actual source code used for my testing.

ORIGINAL: Ron Kuper [Cakewalk]

I'm giving a talk today at AES, and this exact question is covered in it.

I wrote a test program that mixes buffers of (24-bit PCM) noise using 32-bit floats and 64-bit doubles. The mix was then converted back to 24-bit and the results were compared to what the expected result ought to be. The verdict is that using 32-bit floats to mix 24-bit data introduces at most 6dB of error more than 25% of the time.

The program simulates what happens if you mix multiple audio streams using different gains, and scale the result, as shown below
( g1*[S1] + g2*[S2 ] – g1*[S1 ] ) / g2
You would expect the 1st and 3rd streams to cancel each other out, leaving the result of mix to be [S2 ].

The test code looks roughly like this:

	// Fill 2 buffers with noise
 	fillNoise( src1pcm, BUFSIZE );
 	fillNoise( src2pcm, BUFSIZE );
 
 	// Convert to floating point
 	pcmToFloat<float>( src1, src1pcm, BUFSIZE );
 	pcmToFloat<float>( src2, src2pcm, BUFSIZE );
 
 	// Compute (g1*S1+g2*S2-g1*S1)/g2
 	memset( dst, 0, sizeof(dst) );
 	mix<float>( dst, src1, BUFSIZE, gain1 );
 	mix<float>( dst, src2, BUFSIZE, gain2 );
 	mix<float>( dst, src1, BUFSIZE, -gain1 );
 	scale<float>( dst, BUFSIZE, 1.0 / gain2 );
 
 	// Convert answer back to PCM
 	floatToPcm<float>( dst, BUFSIZE );
 
 	// Compare ‘dst’ samples to ‘src2’, count errors
 	. . .

For nearly all values of gain1 and gain2 there is error.

More details to come when we post the slides from my talk. I will also post the actual source code used for my testing.

It seems to me, though I might be wrong, that this is not a big deal. 1 bit of audio is about 6db. Thus a standard audio cd of 16 bits gives you 16 x 6 db = 96 db of dynamic range.
24 bit gives you 144 db of dynamic range.

So as a * rough * comparison recording in 24 bits via 32-bit floats is like a 23 bit recording and recording in 24 bit with 64bit double precision is like recording in true 24 bit. But this is an oversimplication because Ron says that the 6db is the * MAX * error and even that only occurrs 25% of the time--not always.

But I am not bothered that the last bit (the 24th or the 138-144db range) is affected since I dither and chop it down to 16 bits anyway for CD.

True there is error propagation and all that but in the end both recordings (32 bit and 64 bit) are going to sound excellent. I mean its like getting a 98 on a test or a 99--both are very close and should make you happy.

Yeah, I don't think 1 LSB is too big a deal, especially at 24 bits my soundcard really only has a dynamic range of 109 dB (18 bits). The rest is lost in the "noise."

ORIGINAL: Jake68

Ron, honestly can I ask,

Which is best for summing?

Is the difference so slight its inaudible?

Lots of other people are telling me that there are no audible differences in mix engines when pan laws dont come into play. If this is the case why burdon the system with extra overheads.

It would be great if you go explain the matter in laymans terms, I am a writer not a digital mix engineer.

Thanks V Much for your time!