Volume seems soft

[RetiredWizard]

I am finding that the new volume settings are quiet. I set the safe_volume_limit up to 17 which translates to about 10dB which I found was still not loud on both headphones and the speaker. I'm using the version of adafruit_tlv320 that has had @samblenny 's two recent audio PRs merged and I'm curious if others also find that the DAC output is now too soft when using this API.

[samblenny]

I'm less familiar with the volume range for Adafruit_CircuitPython_FruitJam compared to just the TLV320 driver. But, headphones, speakers, and audio devices definitely have a wide range of impedance and sensitivity. It's very plausible that some devices will need considerably more gain than others. For example, in my experience, using the headphone output with audio gear that wants -10 dBV line level input requires about 36 dB above the default headphone volume set by dac.headphone_output = True.

If you want to experiment to find how many dB of gain you need for your headphones or powered speakers (assuming you're using the headphone jack), I'd recommend starting with something like:

dac = TLV320DAC3100(board.I2C())
dac.configure_clocks(sample_rate= 11025, bit_depth=16)
# This will set defaults of: dac_volume -20 dB, headphone_volume = -51.8 dB
dac.speaker_output = False
dac.headphone_output = True

Then increase headphone_volume (like a trim pot or mixer gain knob) until the -20 dB default for dac_volume sounds like a reasonable level for the bottom end of the volume range you'd like to use. After that, use dac_volume as the normal volume control. That should give you a number for how much adjustment you might want to use with this library.

There's also an example app at https://docs.circuitpython.org/projects/tlv320/en/latest/examples.html#volume-test for experimenting with volume levels

[samblenny]

For some additional context on volume adjustments...
It's common for cheap audio mixers to have 40 dB of preamp gain adjustment at the top of a channel strip, then a volume control at the bottom that goes from -∞ to perhaps +10 dB (i.e. total possible boost of 50 dB). Nicer mixers will often have 60 dB or more of preamp gain.

Input channels that are dedicated to line level input (1/4" or phono jacks but not XLR) might be limited to a just a volume knob with a range of perhaps -∞ to +10 or +15 dB. Nicer mixers might also have a trim knob at the top of the channel strip (e.g. ±20 dB).

[relic-se]

Just chiming in on this discussion. I've been using a powered speaker with line level input. The perceptible volume prior to the recent changes were reasonable. After these changes, I've been having to manually set peripherals.dac.dac_volume = -15 after initialization to get audible output, and even then it isn't at the same level as it once was. The default (-51.8 dB) might work for some headphones, but is essentially unusable for line-level output.

I do agree that controlling volume with dac_volume is the best way to do it, but we need to also define a reasonable default for headphone volume. Perhaps add a 3rd Peripherals.audio_output option, "line"?

As an aside, I've noticed that the Peripherals.volume setting is stepped from 1 to 20 as whole numbers which is then mapped out to dBs as a float. Is there a particular reason related to the DAC to have that range? If there isn't a strict reason to limit control in this manner, I would think that a monotonic float (0.0 -> 1.0) would be better suited for this application.

[FoamyGuy]

I've opened: adafruit/Adafruit_CircuitPython_TLV320#12 to raise the default headphone volume a little bit.

As an aside, I've noticed that the Peripherals.volume setting is stepped from 1 to 20 as whole numbers which is then mapped out to dBs as a float. Is there a particular reason related to the DAC to have that range? If there isn't a strict reason to limit control in this manner, I would think that a monotonic float (0.0 -> 1.0) would be better suited for this application.

There is nothing related to the DAC that led to that range. I just picked 1-20 as a simple range that is easy to understand and doesn't have negatives like the db values. I wanted to keep the API very simple, and I figured most people do not have a need for 100 different volume levels, and any kind of up/down button to control it would take a long time to cycle through a list that large. So I settled on 1-20 as a nice range that is easy and understandable and I think will cover the majority of common project use-cases.

Since the DAC object itself offers much more complex control over the volume I figure more advanced users who want something other than the basic 1-20 range can access the DAC directly to manipulate the various volume controls.

[samblenny]

FWIW, you might consider adding some kind of separate gain or trim control (perhaps just soft/medium/loud pad presets?) to act as a calibration for whatever headphones or speakers people want to use, independent of the main volume control. There is such a wide range of hearing ability between humans, and such a wide range of sound output sensitivity levels for speakers and headphones, that a one-size-fits-all default is pretty well guaranteed to be unsuitable for many people.

[dhalbert]

So I settled on 1-20 as a nice range that is easy and understandable and I think will cover the majority of common project use-cases.

I think this was a reasonable choice, but it's also true that 0.0 to 1.0 is even easier to remember, with 1.0 as "max". Display and NeoPixel code uses 0.0 to 1.0.

[FoamyGuy]

I'm open to changing it to use 0.0 - 1.0. Thinking more about the up/down buttons mentioned in my prior comment I realize that doesn't matter much either because code can simply add or subtract larger numbers at once i.e. +/- 0.05 for each button press would still lead to 20 total distinct volumes to cycle through.

[FoamyGuy]

FWIW, you might consider adding some kind of separate gain or trim control (perhaps just soft/medium/loud pad presets?) to act as a calibration for whatever headphones or speakers people want to use, independent of the main volume control. There is such a wide range of hearing ability between humans, and such a wide range of sound output sensitivity levels for speakers and headphones, that a one-size-fits-all default is pretty well guaranteed to be unsuitable for many people.

I agree that it's tricky or impossible to have a single solution that will work for everything.

We could maybe add gain control but I worry that it could mess with the save_volume_limit concept. If there is some way that in can be implemented without adding too much complexity to the API, and still making the safe_volume_limit serve it's purpose of protecting against potential blowout on small speakers then I'd be happy to see it added.

[TheKitty]

Audio folks use 0 or 1 to 10 on amps and the famous Spinal Tap video they go to 11 (hee hee)... Ignore me

[samblenny]

yeah... I wasn't gonna say anything, but a float range of 0 to 11 seems apt.

[relic-se]

@FoamyGuy safe_volume_limit could simply be the top end of the allowable range when mapping to dB. Ie: db_val = map_range(self._volume, 1, 20, -63, min(self._safe_volume_limit, 23)). The current default of 12 (1-20) would map to -13.2 dB in this scenario.

That way, setting volume would always be in a range from 1-20 (or 0.0-1.0, etc) without worrying about triggering a ValueError if your program isn't aware of what safe_volume_limit is set to.

[samblenny]

I agree that it's tricky or impossible to have a single solution that will work for everything.

The volume differences are going to correlate strongly to hardware choice. For the Fruit Jam 1W kit speaker using the speaker connector, it makes sense to have a default tuned to avoid burning up that speaker.

The headphone jack is where things will get tricky depending on the impedance and sensitivity of connected gear. It makes a lot of sense to have a safe volume limit feature that assumes people will be connecting sensitive low impedance earbuds. But, that will make the level too low for anything that needs a line-level input (like powered speakers). I suggest having some kind of constructor argument, settings.toml variable, or settable property that people can use on an opt in basis to make it louder. In the TLV320DAC3100 driver, the headphone_volume property works well for this purpose, but the negative dB units are probably pretty confusing for most folks.

[samblenny]

This is a copy and paste from my recommendation in the driver docs for how to implement a line level output feature:

dac = TLV320DAC3100(board.I2C())
dac.speaker_output = False    # make sure speaker amp is off
dac.headphone_output = True   # set defaults for headphones (note: too low!)

# Make it louder by increasing headphone_volume. We could also use
# dac_volume, but doing it this way gives a better balance between
# the speaker signal chain and the headphone jack signal chain. (think
# of headphone_volume as a mixer channel's pad switch or gain trim knob
# and dac_volume as the main volume control fader)
#
# CAUTION: This will be *way* too loud for earbuds, please be careful!
dac.headphone_volume = -15.5  # default is -51.8 dB

[samblenny]

If it's not clear, what I'm suggesting is:

1. Use dac_volume for the volume control, and apply the safe_volume_limit stuff to whatever mechanism you provide for adjusting dac_volume
2. Provide some kind of additional opt-in gain or trim control, like .line_level_output=True, .boost_volume=True, or whatever, that will adjust headphone_volume to amplify the usable range of dac_volume. This might be controlled by a settings.toml variable or constructor argument. Probably it would not make sense to apply safe_volume_limit to this mechanism because the whole point is to boost output for line level that is beyond a safe level for earbuds.
3. Optionally provide a similar property for adjusting speaker_volume if people want to use a different speaker than the one in the Fruit Jam kit

[relic-se]

I still think that adding a 3rd option, "line", to Peripherals.audio_output is a good way to go here. The implementation would be something like:

if audio_output in {"headphone", "line"}:
    self._dac.headphone_output = True
    self._dac.speaker_output = False
    self._dac.headphone_volume = -15.5 if audio_output == "line" else -51.8
elif audio_output == "speaker":
    ...

Then, I agree that maybe we only apply the safe_volume_limit if audio_output = "speaker". This would play nicely with the config settings in Fruit-Jam-OS as well.

(Btw, I'm just using -51.8 here because it's the default. Idk what exactly would be appropriate.)