Integer is King? - the challenge

[living sounds]

Yes, they do. But judging by the mixes you post here from time to time either your ears or your monitoring somewhat don't.

Maybe you shouldn't take so much time attacking people in forums?

hey, at least we've confirmed your ears still somewhat function.

[Kingston]

OK, I'm out of here. I'd love to debate seriously about these things in order to increase the quality of plugins (I'd REALLY love to work ITB), but it's false assumptions and childish bossiness all the time. You're picking straws in my arguments instead of addressing the real issue (which you'd rather not like to be true).

Just to finish this: Nowhere have I claimed hardware or integers or the like to have a sound. Instead I've merely pointed out specific sonic attributes that are different (I'd say superior) in specific digital units to (theoretically equally capable) plugins. It goes without saying that a rational explanation has to exist for this phanomenon.

BTW, the 480l is identifiable by the way resonances occur (it sounds smoother), the reverb blends with the background, the overall sound is more one of space rather than a reverb tail and the way transients are handled (convolution smears). But Altiverb is really not bad, much better than many other plugins.

yes but absolutely no one here has claimed a specific set of convolution impulses would sound similar to an algorithmic reverb X from the early eighties.. it's ridiculous to even use it as an argument and just goes to show how hopelessly ill-equipped you are for this discussion in the first place. the CSR vs. L300 is just as balls out ridiculous, as I tried to point out with the TB303 and SH101 example.

[vonRed]

Ok guys,

after enjoying your conversation I throw a simple EQ plugin together.

I guess that means I'm off the hook. Although I was planning to use a whole bunch of word lengths to get both audible distortions and completely inaudible ones, with some stages in between (was going to write it last weekend, but didn't get to it). Might still though, a simple public domain comparison might be handy to have lying around.

remember 32bit float at full scale (+/-1) equals 23bit integer

24, the sign bit is seperate in 32bit float. 24bit int does not have better precision than 32bit float.

It's more interesting than that though -- the Motorola 24bit DSPs have 56bit accumulators (including 8 bits for overflow), but x86 floating point units have 80bit registers. So, floating point on PC is still more precise (assuming competent programming).

It baffles my mind how differences happening at -180dB levels could somehow propagate into the audio stream. not even magic could make it audible, unless there's a fundamental flaw with the signal processing theory as we know it today.

Remember Clarke's 3rd law -- "Any sufficiently advanced technology is indistinguishable from magic."

[Kingston]

Yes, they do. But judging by the mixes you post here from time to time either your ears or your monitoring somewhat don't.

yes. when all else fails, resort to personal attacks. I do that time to time as well, just not on this thread.

[Christian Budde]

remember 32bit float at full scale (+/-1) equals 23bit integer

24, the sign bit is seperate in 32bit float. 24bit int does not have better precision than 32bit float.

You're right with the sign bit. I was a little confused, because the mantissa couldn't be denormal here. As far as I have understood how floating point works (I had my term in numerical stuff 6 years ago!), floating points are normed to have a hidden leading one, so that the entire variable is normalized. I once did a test:

Code: Select all

for all 24bit words do 
  convert 24bit word to floating point (within the limit of +-1) 
  convert this back to 24bit integer 
  now substract that result from the original one
check if any residual is unequal zero

I was not able to convert the entire range, but that was still years ago. Maybe I did something wrong with the rounding those days...

[living sounds]

I do this only when seriously provoked. It really sucks to contribute here striving for better sound and have people call you a clueless sucker whose ears have failed him. Learn how to debate and I won't resort to such tactics.

[nuffink]

I do this only when seriously provoked. It really sucks to contribute here striving for better sound and have people call you a clueless sucker whose ears have failed him. Learn how to debate and I won't resort to such tactics.

There are plenty of people in this thread "striving for better sound". You're not one of them.

What you are striving for is objective justification of your subjective taste. A fools errand.

[Christian Budde]

Ok, here are the plots:


(harmonic distortion, purple: double, red: int64)


(harmonic distortion: residual noise, purple: double, red: int64)


(impulse response, purple: double, red: int64)

Always note the scale! We are _far_ under the hearing threshold here. Especially in case of the harmonic distortion test, where the sine would completely mask any tiny difference.
Within the so-called 'power' plot, you can clearly see a limit cycle due to missing dither/noiseshaper. However this is even more inaudible since it starts at about -250dBFS!!!

The first two plots were taken with some more or less extreme settings (3 bands attenuation with small bandwidth, then 3 bands gain back to normal). The last plot was done using a 'bread and butter' equalisation with all seven bands...

The more detailed analysis is up to you!

Christian

[living sounds]

You've really got to learn to deal with other people in a professional manner.

My "subjective taste" is most probably shared by the majority of listeners. Otherwise records wouldn't be created to sound the way they do. People generelly tend to like "punch", "clarity", "texture" etc.

The truth of the matter is that you're a true believer in the sonic equality of plugins. I won't argue any more with you as it is pointless with true believers.

I do this only when seriously provoked. It really sucks to contribute here striving for better sound and have people call you a clueless sucker whose ears have failed him. Learn how to debate and I won't resort to such tactics.

There are plenty of people in this thread "striving for better sound". You're not one of them.

What you are striving for is objective justification of your subjective taste. A fools errand.

[nuffink]

You've really got to learn to deal with other people in a professional manner.

My "subjective taste" is most probably shared by the majority of listeners. Otherwise records wouldn't be created to sound the way they do. People generelly tend to like "punch", "clarity", "texture" etc.

The truth of the matter is that you're a true believer in the sonic equality of plugins. I won't argue any more with you as it is pointless with true believers.

I do this only when seriously provoked. It really sucks to contribute here striving for better sound and have people call you a clueless sucker whose ears have failed him. Learn how to debate and I won't resort to such tactics.

There are plenty of people in this thread "striving for better sound". You're not one of them.

What you are striving for is objective justification of your subjective taste. A fools errand.

At no time have I expressed a belief in the sonic superiority of plugins. Here or in any other thread.
Unlike you I don't confuse my subjective taste with objective measurement.

[BorrelNote]

Thanks Crhristian for your effort

[vonRed]

I once did a test:

Code: Select all

for all 24bit words do 
  convert 24bit word to floating point (within the limit of +-1) 
  convert this back to 24bit integer 
  now substract that result from the original one
check if any residual is unequal zero

I was not able to convert the entire range, but that was still years ago. Maybe I did something wrong with the rounding those days...

Here's a quick test program in C++

Code: Select all

#include "iostream"

using namespace std;

int wmain(int argc, wchar_t* argv[])
{
	for (int i = -(1 << 23), d; i < (1 << 23); i++) {
		float f = static_cast<float>(i);

		if (d = i - static_cast<int>(f)) {
			wcout << i << L" came back with a delta of " << d << endl;
		}
	}
	return 0;
}

It compiles to

Code: Select all

#include "iostream"

using namespace std;

int wmain(int argc, wchar_t* argv[])
{
004114F0 55               push        ebp  
004114F1 8B EC            mov         ebp,esp 
004114F3 81 EC E4 00 00 00 sub         esp,0E4h 
004114F9 53               push        ebx  
004114FA 56               push        esi  
004114FB 57               push        edi  
004114FC 8D BD 1C FF FF FF lea         edi,[ebp-0E4h] 
00411502 B9 39 00 00 00   mov         ecx,39h 
00411507 B8 CC CC CC CC   mov         eax,0CCCCCCCCh 
0041150C F3 AB            rep stos    dword ptr es:[edi] 
	for (int i = -(1 << 23), d; i < (1 << 23); i++) {
0041150E C7 45 F8 00 00 80 FF mov         dword ptr [i],0FF800000h 
00411515 EB 09            jmp         wmain+30h (411520h) 
00411517 8B 45 F8         mov         eax,dword ptr [i] 
0041151A 83 C0 01         add         eax,1 
0041151D 89 45 F8         mov         dword ptr [i],eax 
00411520 81 7D F8 00 00 80 00 cmp         dword ptr [i],800000h 
00411527 7D 6D            jge         wmain+0A6h (411596h) 
		float f = static_cast<float>(i);
00411529 DB 45 F8         fild        dword ptr [i] 
0041152C D9 5D E0         fstp        dword ptr [f] 

		if (d = i - static_cast<int>(f)) {
0041152F D9 45 E0         fld         dword ptr [f] 
00411532 E8 EB FB FF FF   call        @ILT+285(__ftol2_sse) (411122h) 
00411537 8B 4D F8         mov         ecx,dword ptr [i] 
0041153A 2B C8            sub         ecx,eax 
0041153C 89 4D EC         mov         dword ptr [d],ecx 
0041153F 74 53            je          wmain+0A4h (411594h) 
			wcout << i << L" came back with a delta of " << d << endl;
00411541 8B F4            mov         esi,esp 
00411543 A1 3C A3 41 00   mov         eax,dword ptr [__imp_std::endl (41A33Ch)] 
00411548 50               push        eax  
00411549 8B FC            mov         edi,esp 
0041154B 8B 4D EC         mov         ecx,dword ptr [d] 
0041154E 51               push        ecx  
0041154F 68 F8 7B 41 00   push        offset string L" came back with a de"... (417BF8h) 
00411554 8B DC            mov         ebx,esp 
00411556 8B 55 F8         mov         edx,dword ptr [i] 
00411559 52               push        edx  
0041155A 8B 0D 40 A3 41 00 mov         ecx,dword ptr [__imp_std::wcout (41A340h)] 
00411560 FF 15 24 A3 41 00 call        dword ptr [__imp_std::basic_ostream<wchar_t,std::char_traits<wchar_t> >::operator<< (41A324h)] 
00411566 3B DC            cmp         ebx,esp 
00411568 E8 55 FC FF FF   call        @ILT+445(__RTC_CheckEsp) (4111C2h) 
0041156D 50               push        eax  
0041156E E8 B9 FB FF FF   call        std::operator<<<wchar_t,std::char_traits<wchar_t> > (41112Ch) 
00411573 83 C4 08         add         esp,8 
00411576 8B C8            mov         ecx,eax 
00411578 FF 15 24 A3 41 00 call        dword ptr [__imp_std::basic_ostream<wchar_t,std::char_traits<wchar_t> >::operator<< (41A324h)] 
0041157E 3B FC            cmp         edi,esp 
00411580 E8 3D FC FF FF   call        @ILT+445(__RTC_CheckEsp) (4111C2h) 
00411585 8B C8            mov         ecx,eax 
00411587 FF 15 44 A3 41 00 call        dword ptr [__imp_std::basic_ostream<wchar_t,std::char_traits<wchar_t> >::operator<< (41A344h)] 
0041158D 3B F4            cmp         esi,esp 
0041158F E8 2E FC FF FF   call        @ILT+445(__RTC_CheckEsp) (4111C2h) 
		}
	}
00411594 EB 81            jmp         wmain+27h (411517h) 
	return 0;
00411596 33 C0            xor         eax,eax 
}
00411598 5F               pop         edi  
00411599 5E               pop         esi  
0041159A 5B               pop         ebx  
0041159B 81 C4 E4 00 00 00 add         esp,0E4h 
004115A1 3B EC            cmp         ebp,esp 
004115A3 E8 1A FC FF FF   call        @ILT+445(__RTC_CheckEsp) (4111C2h) 
004115A8 8B E5            mov         esp,ebp 
004115AA 5D               pop         ebp  
004115AB C3               ret

As you can see, it stores the floating point value in memory in 32 bits. It always reports a delta of 0.

[Kingston]

People generelly tend to like "punch", "clarity", "texture" etc.

not in a mostly scientific thread, which is why you're witnessing hostility and derision. bullshit subjectivity like that can only get in the way. standing up in arms with words like that against a big bunch a developers looks quite silly.

without further a do, I honestly think you should go back to gearslutz.

[Aldo]

As you can see, it stores the floating point value in memory in 32 bits. It always reports a delta of 0.

Of course
32bit ieee floats can represent 24 bit integer values perfectly; the opposite is not true and you will need some kind of dithering (possibly with a valid psycho-acoustical correction model - maybe with feedback error correction too) to convert from float32 to int24. You will lose information anyway.

[vonRed]

I forgot to normalise the values in the above test, so

Code: Select all

#include "iostream"

using namespace std;

int wmain(int argc, wchar_t* argv[])
{
	for (int i = -(1 << 23), d; i < (1 << 23); i++) {
		float f = static_cast<float>(i) / (1 << 23);

		if (d = i - static_cast<int>(f * (1 << 23))) {
			wcout << i << L" came back with a delta of " << d << endl;
		}
	}
	return 0;
}

The pertinent part of the disassembly

Code: Select all

		float f = static_cast<float>(i) / (1 << 23);
00411539 DB 45 F8         fild        dword ptr [i] 
0041153C DC 35 40 79 41 00 fdiv        qword ptr [__real@4160000000000000 (417940h)] 
00411542 D9 5D E0         fstp        dword ptr [f] 

		if (d = i - static_cast<int>(f * (1 << 23))) {
00411545 D9 45 E0         fld         dword ptr [f] 
00411548 DC 0D 40 79 41 00 fmul        qword ptr [__real@4160000000000000 (417940h)] 
0041154E E8 CF FB FF FF   call        @ILT+285(__ftol2_sse) (411122h) 
00411553 8B 4D F8         mov         ecx,dword ptr [i] 
00411556 2B C8            sub         ecx,eax

As expected, same result.