Make NonlinearFader work with fixed 0..1000 range, not 0..height().

In particular, this fixes an issue where the range could be wrong
just after the widget is created, but the page it is not is not shown
yet (so there hasn't been a resize event yet).

Also makes for more consistent scroll wheel and arrow key behavior,
as it is not longer dependent on widget size.

Interpolate gain changes smoothly, reusing the gain fading code from the EQ.

Reenable simple audio.

Now that most of the multichannel work has been done, we can put the
wraps back on and reenable the simple audio model from 1.3.x, which is
less flexible but also easier for the casual user. Users can choose
between the old model (simple) and the new (multichannel) through a
UI toggle, or with a command-line flag; they map to the same processing
code.

Make it possible to use PgUp/PgDown to switch audio pages.

Do not use the timing of dropped frames as part of the video master clock.

Hopefully improves resampling somewhat when we are dropping frames;
it is tricky to deal with such an uneven master clock, though.

Interpolate EQ changes smoothly, just like volume changes.

Shut down the ALSA probe retry threads cleanly on exit.

Shut down the ALSA inotify thread cleanly on exit.

Move ALSAPool into its own file; it is pretty large now.

Let settings follow buses when editing the mapping.

If a user wants to add a new bus (or delete one), we shouldn't
delete all their settings. Track them as a nicely bound-together
hidden state when editing. (This also lays the ground for
serialization of the entire mixer state in the future,
should we want to do that.)

Actually set the fader positions when making the views for each audio bus.

Make it possible to load an audio input mapping on start, through a command-line flag.

Make it possible to load/save input mappings.

Settings these up can be a bit of a hassle if you have a lot of them,
so we allow them to be saved to disk and then loaded back (complete
with machinery for fuzzy-matching devices if the state has changed,
e.g. cards moved around).

This introduces a dependency on protocol buffers, because it's a
convenient way to store simple data to disk (including forward
compatibility). We choose to use the text format for the user's
convenience; we don't need the speed or compactness of the binary format.

Move InputMapping and friends into its own header file.

Rename “name” to “display name”.

This makes for less confusion when AudioDevice's “name” doesn't
match what's in ALSA's “name” (it is composed of name+info).

Make sure AudioDevice::name is set for ALSA cards, not just video capture cards.

Update to a bmusb version where fake cards output 8-channel audio.

Update the UI with state changes and new ALSA cards as they come in.

Unplug ALSA cards as soon as we get the inotify message.

If not, devices not in use would not be properly removed before
someone tried to remove them.

If a dead device comes back, put it into the right slot.

This fulfills one of the basic goals of hotplug, namely that a sound
card can disappear (ie., lost cable), be replugged and then safely
come back without any manual intervention.

When we stop capturing from an ALSA card, close the PCM handle a bit sooner.

When an ALSA input goes away, replace it by silence.

Silences the warning spew from the resampler that no data is coming.

Make ALSA initialization errors fail-soft.

Instead of exit(1) whenever something in ALSA initialization fails,
we now return false and try again after a second. (This means we could
potentially be doing init for a long time, so it is moved to the
capture thread.)

Support limited ALSA hotplug.

We don't support removing cards yet (we still just exit on error),
and thus also not replacing dead cards with re-plugged ones.
We also don't communicate changed state to the UI yet, and retry
could still be improved.

Refactor ALSA code in preparation for hotplug.

In particular, all the inputs are not owned by a class ALSAPool,
which also takes over enumeration. There's a new state machine
(only in preparation, not actually used yet), and some policy
has been defined for what to do when cards go in and out.

Add a global variable for the audio mixer; it was getting too tedious.

Update the zita-reampler SSE2 patch.

This version supports not only two channels, but mono, stereo or
multiples of four. (In time, we might reorganize so that
e.g. 11 channels are split into 8-, 2- and 1-channel resamplers.)

Set a default locut cutoff, for the benchmark.

Fix an issue where cutoff would not be properly marked when setting new mappings.

Hook up the EQ controls and labels.

Implement the EQ in AudioMixer. (No UI yet.)

Add support for EQ filters to the Filter class.

Make it possible to click the bus peak label to reset it.

When the fader is moved, interpolate its volume over the next frame.

Faders are among the things one should definitely be allowed to move
around during an actual mix without hearing clicking; the gain and threshold
is maybe somewhat less so, so I won't give it the same treatment, at least not
right now.

Show historic peak of each bus under the peak meter.

Replace the R128 meters for each channel with a digital peak meter.

R128 is a superior way of measuring loudness, but for each bus, we care more
about getting the recording levels right (ie., that we don't peak) than loudness.
Since we do our mixing in float, unlike a typical digital mixer, it's not as
critical (at least assuming that the limiter is on and will save us later in
the mastering chain), but it's probably better to be consistent with convention
here.

Thus, use a simple digital meter for each bus, even though we of course still
use R128 for the mastering section.

Split VUMeter into a left and right side, so one can (optionally) have stereo meters.

Remove an (easily-predictable) branch from the StereoCompressor inner loop.

Add a correctness test to the audio benchmark.

Add some low-volume 24-bit data to the benchmark, for variety.

Fix a small theoretical inefficiency; does not actually matter in practice, just cleaner.

Save another ~1% on the audio benchmark, by dealing with the std::deque more efficiently. (Still some potential here.)

Tiny audio optimization (~1%) by making an SSE version of find_peak(); mostly to see whether the benchmark can pick up stuff at all.

Add a benchmark for a simple audio chain; easier than profiling all of Nageru.

Make the compression meters work.

It's possible that the range here needs to be nonlinear,
but we'll deal with that later; for now it's only 0..10 dB
on a linear scale.

This required VU meters that grow downwards, so add that.

Make reference level of VUMeter and LRAMeter adjustable.

Make min/max level of VUMeter and LRAMeter adjustable.

Remove obsolete comment.

Small refactoring in the audio level callback API.

Make it clearer that the cutoff knob affects the channel lo-cut filter.

Move the gain staging and compressors into each bus, and hook up the corresponding controls.

Move the lo-cut into each bus.

Make the faders in the expanded audio view work.

Create buses in the expanded view. (Still inert.)

Hook up the controls on the second (full mode) page.

Add some pagination to the main window.

This allows us to switch between compact and full audio layout.
The full audio layout is not really populated yet; there are only
some widgets (a subset of the compact ones), and they are not
hooked up.

Add a UI file for the expanded audio interface.

Add support for ALSA devices that have no channel maps.

In particular, my Focusrite Scarlett 18i6 presents no such map,
and thus, we'll need to get number of channels some other way.
(For good measure, it refuses to capture unless you ask for at least
14 of the 18 channels.)

Make a non-linear fader for dB use. Not perfect yet, but will do.

Ask for the right number of channels when creating an ALSA device.

Hook up the per-bus VU meters.

Move the R128 and correlation measurements into AudioMixer.

Fix a deadlock issue when shutting down ALSA cards.

Add support for ALSA inputs to the mixer.

Rename reset_device to reset_resampler.

Make the samples_card array capable of storing samples from multiple kinds of cards.

Consistently use “video card” instead of “card”.

Communicate number of channels to the input mapping dialog.

Add a comment about hotswapping issues.

Prepare InputMappingDialog for arbitrary kinds of input source types, by storing the DeviceSpec in the QComboBox items.

Add some ALSA device enumeration code.

Add a class for ALSA audio input. (No enumeration yet.)

Small cleanup in AudioMixer::set_input_mapping().

Prepare for inputs of another frequency than the capture frequency.

Add support for 16-bit audio.

Make AudioMixer ready for indexing on multiple types of devices.

Make remove/up/down buttons work.

Refactor fill_audio_bus() into its own function.

Pick out the right channels when resampling.

Rename InputMapping::Input to InputMapping::Bus; it's less ambiguous.

Make AudioMixer respect the input mapping.

There are tons of TODOs left, and it's totally unoptimized, but it's
nearing something that could in theory actually be used.

Populate the audio miniview from the mapping.

Make most of the input mapping dialog actually work.

You can now add new mappings and edit them, but not delete existing ones
or move them around. OK/Cancel works and actually sets the mapping
in the AudioMixer, but the AudioMixer doesn't care (and neither does the UI).

Tweak the look of the input mapping dialog box a bit.

Store an input mapping, and show it in the UI.

Edits you do in the UI are not actually editable yet, and the mixer doesn't
care about the mapping either.

Add a beginning UI for mapping inputs. No logic connected yet.

Make the final makeup gain adjustment a little faster; 100 seconds was probably a tad too conservative, and painfully slow.

Fix a bug where the automatic makeup gain adjustment would never quite get to the right level.

Actually activate the faders.

Make some common decibel macros.

Some minor IWYU work in mixer.h.

Move most of the audio processing logic from Mixer into a new class, AudioMixer.

Mix all channels instead of just picking one (very rough, no volume control or anything).

Start adding some faders for the miniview (they don't do much yet).

libbmusb-dev has been in testing for a while.

Make the UI show free disk space, and a rough estimation of for how much longer we can record.

Don't call avio_closep() unless we actually have an output file (e.g. in the stream mux).

Remove an obsolete comment.

Fix a file descriptor leak.

Do not use the timing of dropped frames as part of the video master clock.

Hopefully improves resampling somewhat when we are dropping frames;
it is tricky to deal with such an uneven master clock, though.