Author: geoff

B&O Tech: Reading Spec’s – Part 2

#96 in a series of articles about the technology behind Bang & Olufsen loudspeakers

Introduction

It’s been a long time (about 11 years or so…) since I wrote Part 1 in this “series”, so it’s about time that I came out with a Part 2. This one is about the ‘Maximum Sound Pressure Level (SPL)’ and the ‘Bass Capability’ values that are shown for each loudspeaker model on the Bang & Olufsen website.

Before I explain either of those numbers, we need to discuss the fact that B&O loudspeakers are fully-active. This means that all the signal processing, including simple things like the volume control and more complicated things like filtering and crossovers for the loudspeaker drivers happen in a digital signal processing (DSP) chain before the amplifiers, which are individually connected to the loudspeaker drivers. (In other words, if you see a woofer and a tweeter, then there are two amplifiers inside the loudspeaker, one for each.)

That DSP chain includes even more complicated features that help to protect the loudspeaker from abuse. This means that, even if you’re playing a signal that’s been mastered at a high level, and you’ve cranked up the volume control, the processor prevents things like:

  • letting the loudspeaker drivers exceed their maximum excursions
  • letting the amplifiers go beyond their voltage or current capabilities
  • letting the power supply try to deliver more current than it can to the entire system
  • letting the loudspeaker’s internal components get so hot that things start to melt.

(None of this means that it’s impossible to break the loudspeaker. It just means that you’d have to try a lot harder than you would with a lot of other companies’ loudspeakers.)

One important side-effect of all of those protection algorithms is that, when you play a loud signal at maximum volume, the loudspeaker will be constantly trying to protect itself. Therefore its maximum output level will vary over time, depending on the signal you’re playing and things like the temperatures of its various individual components.

This, in turn, makes it difficult to state what the “Maximum Sound Pressure Level” will be, since it will change over time with different conditions.

On the other hand, it’s necessary to give a number that states the maximum Sound Pressure Level of each loudspeaker for lots of reasons. It’s also necessary that we use the same procedure to do the measurement so that the values can be compared from loudspeaker to loudspeaker.

The method

So, how do we balance these two things? The answer is to make the measurement short enough that we show the maximum output of the loudspeakers when it’s hitting its limits without being affected by a build-up of heat. This can give you an idea of how loud a short-term signal (like the punch of a kick drum or a snare drum hit) can play: the Maximum SPL. Whatever that number is, the loudspeaker definitely can’t play louder than it (since the amplifier can’t deliver more current and the loudspeaker drivers can’t move in and out any further) but that doesn’t necessarily mean it can play at that level continuously.

The way we measure both the Maximum SPL and the Bass Capability is by placing a microphone 1 m in front of the loudspeaker, and then putting in a short ‘burst’ of 5 periods of a sinusoidal tone at a given frequency. The sound pressure level of the output is measured at the microphone’s position, we wait long enough for everything to cool down, the level of the incoming signal is increased, and then we do the measurement again. This is repeated until the output signal’s level is being automatically reduced by the loudspeaker’s protection algorithms by a pre-determined amount (-6 dB).

If we were a company that made passive loudspeakers, a normal way to do this would be to increase the level until we reached a pre-determined level of total harmonic distortion (say, 10% or 20% THD, for example). However, this won’t work for a B&O loudspeaker because the protection algorithms probably won’t allow the product to distort enough to have a usable threshold.

What’s the difference?

Generally, the method of measuring both the Maximum SPL and the Bass Capability values are the same. The only difference is the range of frequencies that are used for each.

The Bass Capability shows the maximum SPL of the loudspeaker when the input signal is a 50 Hz sinusoidal wave.*

The Maximum Sound Pressure Level is an average of the maximum SPL of the loudspeaker when it is measured using a number of sinusoidal signals ranging from 200 Hz to 2 kHz. Each frequency is measured individually, and the resulting maxima are averaged to produce a single value. (If you’re read Part 1, then the frequency range of this measurement will look familiar.)

How does this correspond to real life?

This is a difficult question to answer, since the measurement is done on-axis to (or ‘directly in front of’) the loudspeaker in the measurement room. This measurement room is different from a ‘normal’ living room, where more of the total power of the loudspeaker that’s radiated in all three dimensions is reflected back to the listening position. This is the reason why some companies list the maximum output level of their loudspeakers with two numbers: one in a ‘free field’ (a room or ‘field’ that is ‘free’ of reflections) and the other in a ‘listening room’ (which may or may not be like your listening room). You’ll probably see that the ‘listening room’ SPL is higher than the ‘free field’ SPL because the room is reflecting more energy back to the measurement microphone, if nothing else…

In other words ‘results may vary’. So, the maximum SPL of a loudspeaker in your living room may not be the same as the Maximum SPL that B&O lists on its website. Time frames are different, signals are different, and rooms are different: and all of these have significant effects on the result.

What happens when I have more than one loudspeaker?

Generally speaking, if your loudspeakers are reasonably far apart, then you can use a simple rule to calculate the maximum SPL if you add more loudspeakers.

+ 3 dB per doubling

In other words, if you have a loudspeaker that can hit 100 dB SPL, and you add a second loudspeaker, then you’ll hit 103 dB SPL. If you then add two more loudspeaker (another doubling of the total number) you’ll hit 106 dB SPL.

This rule is based on a number of assumptions:

  • the loudspeakers are all the same type
  • the loudspeakers are in the same room, but fairly far apart
  • the loudspeakers are all playing their maximum output levels at the same time
  • I’m ignoring room modes, which might make things louder or quieter, depending on the frequency that you’re playing, the placements of the loudspeakers, and the location of the listening position
  • we’re ignoring other protection algorithms like thermal protection

The reason that this rule is a basic one: we’re assuming that every time you double the number of speakers, you double the total power at the listening position (which is a reasonable assumption if the list of assumptions above are true). Two times the acoustic power is the same as an increase of +3 dB SPL (because 10 log10(2) = 3).

If, however, the frequency was very low, and the loudspeakers were very close together, and they were playing exactly the same signals at exactly the same time, you might make the argument that you can say that there is a +6 dB increase for every doubling of loudspeakers, because it’s their amplitudes (and not their acoustic powers) that are added.

Neither of these two basic assumptions is correct, and so the real number is probably between +3 and +6 dB per doubling of loudspeakers, and it will be different for different frequency bands and different loudspeaker separations. However, it’s best to err on the safe side.

One last thing

This should help to explain why, when you compare the Bass Capabilities and the Maximum Sound Pressure Levels of different loudspeakers, the former has much bigger differences than the latter.

For example:

Beosound Explore< difference >Beolab 50
Max SPL @ 1 m91 dB SPL26 dB117 dB SPL
Bass capability59 dB SPL52 dB111 dB SPL

The table above shows a direct comparison of two VERY different loudspeaker models using data taken directly from bang-olufsen.com on 2025 04 01. I’ve converted the numbers for the Beolab 50 to a ‘per loudspeaker’ instead of ‘per pair’ by subtracting 3 dB from the published numbers.

As you can see there:

  • the difference in Bass Capability between a Beosound Explore and a Beolab 50 is (111-59) = 52 dB
  • the difference in Max SPL between a Beosound Explore and a Beolab 50 is (117-91) = 26 dB

Speaking VERY generally, the difference in Max SPL values is less than the difference in Bass Capabilities because the difference in size and power of the drivers producing the midrange frequency band of the two loudspeakers is smaller than the difference in size and power of the woofers. In other words, there is a difference between the different differences. (I think that I got that right…)

* To get the Bass Capability measurement, it looks like I said that we do the measurement of a single 50 Hz sinusoidal tone. This isn’t really true. We do a number of measurements at different frequencies ranging from 20 Hz to 100 Hz and then calculate the equivalent value for a 50 Hz tone using some averaging.

If the loudspeaker is comprised of a single low-frequency driver in a closed cabinet, then the resulting number would be the same as if we just measured using a 50 Hz tone. However, if the loudspeaker is ported or has a passive driver with a resonant frequency in the 20 – 100 Hz range, then this method will probably produce a slightly different number than measuring only with a 50 Hz tone.

I wrote this

Everything that you read on this website was written by me without the help of AI. I promise.

I, for one, am sick and tired of the word salads that are getting put on websites by people who feed some keywords in a large language model, and then copy-and-paste the results without any kind of critical thinking, or even a modicum of copy editing. (Even worse are the automatically-generated webpages that are created from the keywords in your search, where the only human in the process is you.) The result is usually something that looks like it should make sense, but winds up being confusing because you’re actually trying to navigate in a sea of errors.

I’ve also debated for a long time whether to try to block LLMs from scraping this site to feed their salad bowls. For now, I’ve decided that I will give it a try, using the Block AI Crawlers plugin for WordPress.

The Sound of Music

This episode of The Infinite Monkey Cage is worth a listen if you’re interested in the history of recording technologies.

There’s one comment in there by Brian Eno that I COMPLETELY agree with. He mentions that we invented a new word for moving pictures: “movies” to distinguish them from the live equivalent, “plays”. But we never really did this for music… Unless, of course, you distinguish listening to a “concert” from listening to a “recording” – but most of us just say “I’m listening to music”.

100-year old upmixer

I had a little time at work today waiting for some visitors to show up and, as I sometimes do, I pulled an old audio book off the shelf and browsed through it. As usually happens when I do this, something interesting caught my eye.

I was reading the AES publication called “The Phonograph and Sound Recording After One-Hundred Years” which was the centennial issue of the Journal of the AES from October / November 1977.

In that issue of the JAES, there is an article called “Record Changers, Turntables, and Tone Arms – A Brief Technical History” by James H. Kogen of Shure Brothers Incorporated, and in that article he mentions US Patent Number 1,468,455 by William H. Bristol of Waterbury, CT, titled “Multiple Sound-Reproducing Apparatus”.

Before I go any further, let’s put the date of this patent in perspective. In 1923, record players existed, but they were wound by hand and ran on clockwork-driven mechanisms. The steel needle was mechanically connected to a diaphragm at the bottom of a horn. There were no electrical parts, since lots of people still didn’t even have electrical wiring in their homes: radios were battery-powered. Yes, electrically-driven loudspeakers existed, but they weren’t something you’d find just anywhere…

In addition, 3- or 2-channel stereo wasn’t invented yet, Blumlein wouldn’t patent a method for encoding two channels on a record until 1931: 8 years in the future…

But, if we look at Bristol’s patent, we see a couple of astonishing things, in my opinion.

If you look at the top figure, you can see the record, sitting on the gramophone (I will not call it a record player or a turntable…). The needle and diaphragm are connected to the base of the horn (seen on the top right of Figure 3, looking very much like my old Telefunken Lido, shown below.

But, below that, on the bottom of Figure 3 are what looks a modern-ish looking tonearm (item number 18) with a second tonearm connected to it (item number 27). Bristol mentions the pickups on these as “electrical transmitters”: this was “bleeding edge” emerging technology at the time.

So, why two pickups? First a little side-story.

Anyone who works with audio upmixers knows that one of the “tricks” that are used is to derive some signal from the incoming playback, delay it, and then send the result to the rear or “surround” loudspeakers. This is a method that has been around for decades, and is very easy to implement these days, since delaying audio in a digital system is just a matter of putting the signal into a memory and playing it out a little later.

Now look at those two tonearms and their pickups. As the record turns, pickup number 20 in Figure 3 will play the signal first, and then, a little later, the same signal will be played by pickup number 26.

Then if you look at Figure 6, you can see that the first signal gets sent to two loudspeakers on the right of the figure (items number 22) and the second signal gets sent to the “surround” loudspeakers on the left (items number 31).

So, here we have an example of a system that was upmixing a surround playback even before 2-channel stereo was invented.

Mind blown…

NB. If you look at Figure 4, you can see that he thought of making the system compatible with the original needle in the horn. This is more obvious in Figures 1 and 2, shown below.

Bit depth conversion: Part 5

One of the things I have to do occasionally is to test a system or device to make sure that the audio signal that’s sent into it comes out unchanged. Of course, this is only one test on one dimension, but, if the thing you’re testing screws up the signal on this test, then there’s no point in digging into other things before it’s fixed.

One simple way to do this is to send a signal via a digital connection like S/PDIF through the DUT, then compare its output to the signal you sent, as is shown in the simple block diagram in Figure 1.

Figure 1: Basic block diagram of a Device Under Test

If the signal that comes back from the DUT is identical to the signal that was sent to it, then you can subtract one from the other and get a string of 0s. Of course, it takes some time to send the signal out and get it back, so you need to delay your reference signal to time-align them to make this trick work.

The problem is that, if you ONLY do what I described above (using something like the patcher shown in Figure 2) then it almost certainly won’t work.

Figure 2: The wrong way to do it

The question is: “why won’t this work?” and the answer has very much to do with Parts 1 through 4 of this series of postings.

Looking at the left side of the patcher, I’m creating a signal (in this case, it’s pink noise, but it could be anything) and sending it out the S/PDIF output of a sound card by connecting it to a DAC object. That signal connection is a floating point value with a range of ±1.0, and I have no idea how it’s being quantised to the (probably) 24 bits of quantisation levels at the sound card’s output.

That quantised signal is sent to the DUT, and then it comes back into a digital input through an ADC object.

Remember that the signal connection from the pink noise output across to the latency matching DELAY object is a floating point signal, but the signal coming into the ADC object has been converted to a fixed point signal and then back to a floating point representation.

Therefore, when you hit the subtraction object, you’re subtracting a floating point signal from what is effectively a fixed point quantised signal that is coming back in from the sound card’s S/PDIF input. Yes, the fixed point signal is converted to floating point by the time it comes out of the ADC object – but the two values will not be the same – even if you just connect the sound card’s S/PDIF output to its own input without an extra device out there.

In order to give this test method a hope of actually working, you have to do the quantisation yourself. This will ensure that the values that you’re sending out the S/PDIF output can be expected to match the ones you’re comparing them to internally. This is shown in Figure 3, below.

Figure 3: A better way to do it

Notice now that the original floating point signal is upscaled, quantised, and then downscaled before its output to the sound card or routed over to the comparison in the analysis section on the right. This all happens in a floating point world, but when you do the rounding (the quantisation) you force the floating point value to the one you expect when it gets converted to a fixed point signal.

This ensures that the (floating point) values that you’re using as your reference internally CAN match the ones that are going through your S/PDIF connection.

In this example, I’ve set the bit depth to 16 bits, but I could, of course, change that to whatever I want. Typically I do this at the 24-bit level, since the S/PDIF signal supports up to 24 bits for each sample value.

Be careful here. For starters, this is a VERY basic test and just the beginning of a long series of things to check. In addition, some sound cards do internal processing (like gain or sampling rate conversion) that will make this test fail, even if you’re just doing a loop back from the card’s S/PDIF output to its own input. So, don’t copy-and-paste this patcher and just expect things to work. They might not.

But the patcher shown in Figure 2 definitely won’t work…

One small last thing

You may be wondering why I take the original signal and send it to the right side of the “-” object instead of making things look nice by putting it in the left side. This is because I always subtract my reference signal from the test signal and not the other way around. Doing this every time means that I don’t have to interpret things differently every time, trying to figure out whether things are right-side-up or upside-down.

Bit depth conversion: Part 4

Converting floating point to fixed point

It is often the case that you have to convert a floating point representation to a fixed point representation. For example, you’re doing some signal processing like changing the volume or adding equalisation, and you want to output the signal to a DAC or a digital output.

The easiest way to do this is to just send the floating point signal into the DAC or the S/PDIF transmitter and let it look after things. However, in my experience, you can’t always trust this. (I’ll explain why in a later posting in this series.) So, if you’re a geek like me, then you do this conversion yourself in advance to ensure you’re getting what you think you’re getting.

To start, we’ll assume that, in the floating point world, you have ensured that your signal is scaled in level to have a maximum amplitude of ± 1.0. In floating point, it’s possible to go much higher than this, and there’re no serious reason to worry going much lower (see this posting). However, we work with the assumption that we’re around that level.

So, if you have a 0 dB FS sine wave in floating point, then its maximum and minimum will hit ±1.0.

Then, we have to convert that signal with a range of ±1.0 to a fixed point system that, as we already know, is asymmetrical. This means that we have to be a little careful about how we scale the signal to avoid clipping on the positive side. We do this by multiplying the ±1.0 signal by 2^(nBits-1)-1 if the signal is not dithered. (Pay heed to that “-1” at the end of the multiplier.)

Let’s do an example of this, using a 5-bit output to keep things on a human scale. We take the floating point values and multiply each of them by 2^(5-1)-1 (or 15). We then round the signals to the nearest integer value and save this as a two’s complement binary value. This is shown below in Figure 1.

Figure 1. Converting floating point to a 5-bit fixed point value without dither.

As should be obvious from Figure 1, we will never hit the bottom-most fixed point quantisation level (unless the signal is asymmetrical and actually goes a little below -1.0).

If you choose to dither your audio signal, then you’re adding a white noise signal with an amplitude of ±1 quantisation level after the floating point signal is scaled and before it’s rounded. This means that you need one extra quantisation level of headroom to avoid clipping as a result of having added the dither. Therefore, you have to multiply the floating point value by 2^(nBits-1)-2 instead (notice the “-2” at the end there…) This is shown below in Figure 2.

Figure 2. Converting floating point to a 5-bit fixed point value with dither.

Of course, you can choose to not dither the signal. Dither was a really useful thing back in the days when we only had 16 reliable bits to work with. However, now that 24-bit signals are normal, dither is not really a concern.

Bit depth conversion: Part 3

Converting fixed point to floating point

In Part 1 of this series, I talked about three different options for converting from a fixed-point representation to another fixed-point representation with a bigger bit depth.

This happens occasionally. The simplest case is when you send a 16-bit signal to a 24-bit DAC. Another good example is when you send a 16-bit LPCM signal to a 24- or 32-bit fixed point digital signal processor.

However, these days it’s more likely that the incoming fixed-point signal (incoming signals are almost always in a fixed-point representation) is converted to floating point for signal processing. (I covered the differences between fixed- and floating-point representations in another posting.)

If you’re converting from fixed point to floating point, you divide the sample’s value by 2^(nBits-1). In other words, if you’re converting a 5-bit signal to floating point, you divide each sample’s value by 2^4, as shown below.

Figure 1. Converting a 5-bit fixed point signal to floating point

The reason for this is that there are 2^(nBits-1) quantisation levels for the negative portions of the signal. The positive-going portions have one fewer levels due to the two’s complement representation (the 00000 had to come from somewhere…).

So, you want the most-negative value to correspond to -1.0000 in the floating point world, and then everything else looks after itself.

Of course, this means that you will never hit +1.0. You’ll have a maximum signal level of 1 – 1/2^(nBits-1), which is very close. Close enough.

The nice thing about doing this conversation is that by entering into a floating point world, you immediately gain resolution to attenuate and headroom to increase the gain of the signal – which is exactly what we do when we start processing things.

Of course, this also means that, when you’re done processing, you’ll need to feed the signal out to a fixed-point world again (for example, to a DAC or to an S/PDIF output). That conversion is the topic of Part 4.

Bit depth conversion: Part 2

Binary concatenation and bit splitting

In Part 1, I talked about different options for converting a quantised LPCM audio signal, encoded with some number of bits into an encoding with more bits. In this posting, we’ll look at a trick that can be used when you combine these options.

To start, made two signals:

  • “Signal 1” is a sinusoidal tone with a frequency of 100 Hz.
    It has an amplitude of ±1, but then encoded it as a quantised 8-bit signal, so in Figure 1, it looks like it has an amplitude of ±127 (which is 2^(nBits-1)-1)
  • “Signal 2” is a sinusoidal tone with a frequency of 1 kHz and the same amplitude as Signal 1.

Both of these two signals are plotted on the left side of Figure 1, below. On the right, you can see the frequency content of the two signals as well. Notice that there is plenty of “garbage” at the bottom of those two plots. This is because I just quantised the signals without dither, so what you’re seeing there is the frequency-domain artefacts of quantisation error.

Figure 1. Two sinusoidal waveforms with different frequencies. Both are 8-bit quantised without dither.

If I look at the actual sample values of “Signal 1” for the first 10 samples, they look like the table below. I’ve listed them in both decimal values and their binary representations. The reason for this will be obvious later.

Sample numberSample value (decimal)Sample Value (binary)
1000000000
2200000010
3300000011
4500000101
5700000111
6800001000
71000001010
81200001100
91300001101
101500001111

Let’s also look at the first 10 sample values for “Signal 2”

Sample numberSample value (decimal)Sample Value (binary)
1000000000
21700010001
33300100001
44900110001
56300111111
67701001101
79001011010
810101100101
911001101110
1011701110101

The signals I plotted above have a sampling rate of 48 kHz, so there are a LOT more samples after the 10th one… however, for the purposes of this posting, the ten values listed in the tables above are plenty.

At the end of the Part 1, I talked about the Most and the Least Significant Bits (MSBs and LSBs) in a binary number. In the context of that posting, we were talking about whether the bit values in the original signal became the MSBs (for Option 1) or the LSBs (for Option 3) in the new representation.

In this posting, we’re doing something different.

Both of the signals above are encoded as 8-bit signals. What happens if we combine them by just slamming their two values together to make 16-bit numbers?

For example, if we look at sample #10 from both of the tables above:

  • Signal 1, Sample #10 = 00001111
  • Signal 2, Sample #10 = 01110101

If I put those two binary numbers together, making Signal 1 the 8 MSBs and Signal 2 the 8 LSBs then I get

0000111101110101

Note that I formatted them with bold and italics just to make it easier to see them. I could have just written 0000111101110101 and let you figure it out.

Just to keep things adequately geeky, you should know that “slamming their values together” is not the correct term for what I’ve done here. It’s called binary concatenation.

Another way to think about what I’ve done is to say that I converted Signal 1 from an 8-bit to a 16-bit number by zero-padding, and then I added Signal 2 to the result.

Yet another way to think of it is to say that I added about 48 dB of gain to Signal 1 (20*log10(2^8) = about 48.164799306236993 dB of gain to be more precise…) and then added Signal 2 to the result. (NB. This is not really correct, as is explained below.)

However, when you’re working with the numbers inside the computer’s code, it’s easier to just concatenate the two binary numbers to get the same result.

If you do this, what do you get? The result is shown in Figure 2, below.

Figure 2. The binary concatenated result of Signal 1 and Signal 2

As you can see there, the numbers on the y-axis are MUCH bigger. This is because of the bit-shifting done to Signal 1. The MSBs of a 16-bit number are 256 times bigger in decimal world than those of an 8-bit number (because 2^8 = 256).

In other words, the maximum value in either Signal 1 or Signal 2 is 127 (or 2^(8-1)-1) whereas the maximum value in the combined signal is 32767 (or 2^(16-1)-1).

The table below shows the resulting first 10 values of the combined signal.

Sample numberSample value (decimal)Sample Value (binary)
100000000000000000
25290000001000010001
38010000001100100001
413290000010100110001
518550000011100111111
621250000100001001101
726500000101001011010
831730000110001100101
934380000110101101110
1039570000111101110101

Why is this useful? Well, up to now, it’s not. But, we have one trick left up our sleeve… We can split them apart again, taking that column of numbers on the right side of the table above, cut each one into two 8-bit values, and ta-da! We get out the two signals that we started with!

Just to make sure that I’m not lying, I actually did all of that and plotted the output in Figure 3. If you look carefully at the quantisation error artefacts in the frequency-domain plots, you’ll see that they’re identical to those in Figure 1. (Although, if they weren’t, then this would mean that I made a mistake in my Matlab code…)

Figure 3. The two signals after they’ve been separated once again.

So what?

Okay, this might seem like a dumb trick. But it’s not. This is a really useful trick in some specific cases: transmitting audio signals is one of the first ones to come to mind.

Let’s say, for example, that you wanted to send audio over an S/PDIF digital audio connection. The S/PDIF protocol is designed to transmit two channels of audio with up to 24-bit LPCM resolution. Yes, you can do different things by sending non-LPCM data (like DSD over PCM (DoP) or Dolby Digital-encoded signals, for example) but we won’t talk about those.

If you use this binary concatenation and splitting technique, you could, for example, send two completely different audio signals in each of the audio channels on the S/PDIF. For example, you could send one 16-bit signal (as the 16 MSBs) and a different 8-bit signal (as the LSBs), resulting in a total of 24 bits.

On the receiving end, you split the 24-bit values into the 16-bit and 8-bit constituents, and you get back what you put in.

(Or, if you wanted to get really funky, you could put the two 8-bit leftovers together to make a 16-bit signal, thus transmitting three lossless LPCM 16-bit channels over a stream designed for two 24-bit signals.)

However, if you DON’T split them, and you just play the 24-bit signal into a system, then that 8-bit signal is so low in level that it’s probably inaudible (since it’s at least 93 dB below the peak of the “main” signal). So, no noticeable harm done!

Hopefully, now you can see that there are lots of potential uses for this. For example, it could be a sneaky way for a record label to put watermarking into an audio signal, for example. Or you could use it to send secret messages across enemy lines, buried under a recording of the Alvin and the Chipmunk’s cover of “Achy Breaky Heart”. Or you could use it for squeezing more than two channels out of an S/PDIF cable for multichannel audio playback.

One small issue…

Just to be clear, I actually used Matlab and did all the stuff I said above to make those plots. I didn’t fake it. I promise!

But if you’re looking carefully, you might notice two things that I also noticed when I was writing this.

I said above that, by bit-shifting Signal 1 over by 8 bits in the combined signal, this makes it 48 dB louder than Signal 2. However, if you look at the frequency domain plot in Figure 2, you’ll notice that the 1 kHz tone is about 60 dB lower than the 100 Hz tone. You’ll also notice that there are distortion artefacts on the 1 kHz signal at 3 kHz, 5 kHz and so on – but they’re not there in the extracted signal in Figure 3. So, what’s going on?

To be honest, when I saw this, I had no idea, but I’m lucky enough to work with some smart people who figured it out.

If you go back to the figures in Part 1, you can see that the MSB of a sample value in binary representation is used as the “sign” of the value. In other words, if that first bit is 0, then it’s a positive value. If it’s a 1 then it’s a negative value. This is known as a “two’s complement” representation of the signal.

When we do the concatenation of the two sample values as I showed in the example above, the “sign” bit of the signal that becomes the LSBs of the combined signal no longer behaves as a +/- sign. So, the truth is that, although I said above that it’s like adding the two signals – it’s really not exactly the same.

If we take the signal combined through concatenation and subtract ONLY the bit-shifted version of Signal 1, the result looks like this:

Figure 4. The difference between the combined signals shown in Figure 3 and Signal 1, after it’s been bit-shifted (or zero-padded) by 8 LSBs.

Notice that the difference signal has a period of 1 ms, therefore its fundamental is 1 kHz, which makes sense because it’s a weirdly distorted version of Signal 2, which is a 1 kHz sine tone.

However, that fundamental frequency has a lower level than the original sine tone (notice that it shows up at about -60 dB instead of -48 dB in Figure 2). In addition, it has a DC offset (no negative values) and it’s got to have some serious THD to be that weird looking. Since it’s a symmetrical waveform, its distortion artefacts consist of only odd multiples of the fundamental.

Therefore, when I stated above that you’re “just” adding the two signals together, so there’s no harm done if you don’t separate them at the receiving end. This was a lie. But, if your signal with the MSBs has enough bits, then you’ll get away with it, since this pushes the second signal further down in level.

Bit depth conversion: Part 1

Increasing bit depth in a fixed-point system

This is the first of a series of postings about strategies for converting from one bit depth to another, including conversion back and forth between fixed point and floating point encoding. It’ll be focusing on a purely practical perspective, with examples of why you need to worry about these things when you’re doing something like testing audio devices or transmission systems.

As we go through this, it might be necessary to do a little review, which means going back and reading some other postings I’ve done in the past if some of the concepts are new. I’ll link back to these as we need them, rather than hitting you with them all at once.

To start, if you’re not familiar with the concept of quantisation and bit depth in an LPCM audio signal, I suggest that you read this posting.

Now that you’re back, you know that if you’re just converting a continuous audio signal to a quantised LPCM version of it, the number of bits in the encoded sample values can be thought of as a measure of the system’s resolution. The more bits you have, the more quantisation steps, and therefore the better the signal to noise ratio.

However, this assumes that you’re using as many of the quantisation steps as possible – in other words, it assumes that you have aligned levels so that the highest point in the audio signal hits the highest possible quantisation step. If your audio signal is 6 dB lower than this, then you’re only using half of your available quantisation values. In other words, if you have a 16-bit ADC, and your audio signal has a maximum peak of -6 dB FS Peak, then you’ve done a 15-bit recording.

But let’s say that you already have an LPCM signal, and you want to convert it to a larger bit depth. A very normal real-world example of this is that you have a 16-bit signal that you’ve ripped from a CD, and you export it as a 24-bit wave file. Where do those 8 extra bits come from and where do they go?

Generally speaking, you have 3 options when you do this “conversion”, and the first option I’ll describe below is, by far the most common method.

Option 1: Zero padding

Let’s simplify the bit depths down to human-readable sizes. We’ll convert a 3-bit LPCM audio signal (therefore it has 2^3 = 8 quantisation steps) into a 5-bit representation (2^5 = 32 quantisation steps), instead of 16-bit to 24-bit. That way, I don’t have to type as many numbers into my drawings. The basic concepts are identical, I’ll just need fewer digits in this version.

The simplest method to do is to throw some extra zeros on the right side of our original values, and save them in the new format. A graphic version of this is shown in Figure 1.

Figure 1. Zero-padding to convert to a higher bit depth.

There are a number of reasons why this is a smart method to use (which also explains why this is the most common method).

The first is that there is no change in signal level. If you have a 0 dB FS Peak signal in the 3-bit world, then we assume that it hits the most-negative value of 100. If you zero-pad this, then the value becomes 10000, which is also the most-negative value in the 5-bit world. If you’re testing with symmetrical signals (like a sinusoidal tone) then you never hit the most-negative value, since this would mean that it would clip on the positive side. This might result in a test that’s worth talking about, since sinusoidal tone that hits 011 and is then converted to 01100. In the 5-bit world, you could make a tone that is a little higher in level (by 3 quantisation levels – those top three dotted lines on the right side of Figure 1), but that difference is very small in real life, so we ignore it. The biggest reason for ignoring this is that this extra “headroom” that you gain is actually fictitious – it’s an artefact of the fact that you typically test signal levels like this with sine tones, which are symmetrical.

The second reason is that this method gives you extra resolution to attenuate the signal. For example, if you wanted to make a volume knob that only attenuated the audio signal, then this conversion method is a good way to do it. (For example, you send a 16-bit digital signal into the input of a loudspeaker with a volume controller. You zero-pad the signal to 24-bit and you now have the ability to reduce the signal level by 141 dB instead of just 93 dB (assuming that you’re using dither…). This is good if the analogue dynamic range of the rest of the system “downstream” is more than 93 dB.) The extra resolution you get is equivalent to 6 dB * each extra bit. So, in the system above:

(5 bits – 3 bits) = 2 extra bits
2 extra bits * 6 dB = 12 dB extra resolution

There is one thing to remember when doing it this way, that you may consider to be a disadvantage. This is the fact that you can’t increase the gain without clipping. So, let’s say that you’re building a digital equaliser or a mixer in a fixed-point system, then you can’t just zero-pad the incoming signal and think that you can boost signals or add them. If you do this, you’ll clip. So, you would have to zero-pad at the input, then attenuate the signal to “buy” yourself enough headroom to increase it again with the EQ or by mixing.

Option 2

The second option is, in essence, the same as the trick I just explained in the previous paragraph. With this method, you don’t ONLY pad the right side of the values with zeros, you pad the values on the left as well with either a 1 or a 0, depending on whether the signals are positive or negative. This means that your “old” value is inserted into the middle of the new value, as shown below in Figure 2. (In this 3- to 5-bit example, this is identical to using option 1, and then dropping the signal level by 6 dB (1 of the 2 bits)).

If your conversion to the bigger bit depth is done inside a system where you know what you’ve done, and if you need room to scale the level of the signal up and down, this is a clever and simple way to do things. There are some systems that did this in the past, but since it’s a process that’s done internally, and we normal people sit outside the system, there’s no real way for us to know that they did it this way.

(For example, I once heard through the grapevine that there was a DAW that imported 24-bits into a 48-bit fixed point processing system, where they padded the incoming files with 12 bits on either side to give room to drop levels on the faders and also be able to mix a lot of full-scale signals without clipping the output.)

Option 3

I only add the third option as a point of completion. This is an unusual way to do a conversion, and I only personally know of one instance where it’s been used. This only means that it’s not a common way to do things – not that NO ONE does it.

In this method, all the padding is done on the left side of the binary values, as shown below in Figure 3.

If we’re thinking along the same lines as in Options 1 and 2, then you could say that this system does not add resolution to attenuate signals, but it does give you the option to make them louder.

However, as we’ll see in Part 2 of this series, there is another advantage to doing it this way…

Nota Bene

I’ve written everything above this line, intentionally avoiding a couple of common terms, but we’ll need those terms in our vocabulary before moving on to Part 2.

If you look at the figures above, and start at the red 0 line, as you go upwards, the increase in signal can be seen as an increase in the left-most bits in each quantisation value. Reading from left-to-right, the first bit tells us whether the value is positive (0) or negative (1), but after this (for the positive values) the more 1s you have on the left, the higher the level. This is why we call them the Most Significant Bits or MSBs. Of course, this means that the last bit on the right is the Least Significant Bit or LSB.

This means that I could have explained Option 1 above by saying:

The three bits of the original signal become the three MSBs of the new signal.

… which also tells us that the signal level will not drop when converted to the 5-bit system.

Or I could have explained Option 3 by saying:

The three bits of the original signal become the three LSBs of the new signal.

.. which also tells us that the signal level will drop when converted to the 5-bit system.

Being able to think in terms of LSBs and MSBs will be helpful later.

Finally… yes, we will talk about Floating Point representations. Later. But if you can’t wait, read this in the meantime.