Release Nageru 1.4.2.

Don't bother making AVPackets if x264 has no data for us.

Also gives the first SEI a more sane timestamp.

Fix a thread race that would sometimes cause x264 streaming to go awry.

Fix a window title.

Release Nageru 1.4.1.

Recommend Movit 1.4.0 in the README (fixes some threading issues).

Fix a race during startup.

Doesn't actually matter in practice (only comes into play if pointer
reads/writes are non-atomic), but it's nice to make Helgrind happy.

Update on the libusb status; much better now.

If EGL initialization fails, print a friendlier error message.

The libpci dependency might be a bit overkill, but it really
helps friendliness in an otherwise pretty inscrutinable case.

Fix an issue with streaming the NUT mux to HTTP.

Fix a segfault on bmusb hotplug in simple audio mode.

Release Nageru 1.4.0.

Fix a missing break in a switch.

Found by Coverity Scan (among tons of false positives).

Check the return value of writing to the eventfd.

Fix some missing targets in clean.

Add some missing non-implicit dependencies to the Makefile.

Various Makefile tweaks (mostly related to cleaning moc files).

Clean .pb.{cc,h} files on make clean.

Final touch before release: Remove the MIDI controller debug printfs.

Make the compression meter nonlinear.

This necessitated splitting it out into its own class, which also
took some complexity out of VUMeter.

Split out the piecewise linear interpolation code into its own class.

Fix some UI work being done on the non-UI thread.

Allow using control 0.

Evidently, there are devices that use the entire range,
so the special value has to move to -1.

Don't try to set up MIDI mapper highlights before the UI exists.

Change the auto-gain stopping criterion to be on corrected LU.

This might be less safe (there might be some feedback effects involved),
but the behavior of working on _uncorrected_ LU was simply too unintuitive;
it was hard to understand why the setting wasn't moving.

Give the makeup gain control a bit more useful range (+/- 15 dB instead of 30). Especially relevant with the physical controls.

Re-run include-what-you-use.

Insignificant compile-time savings this time, but still nice
to have it cleaned up.

Update the README for the new sound features.

Add a sample MIDI mapping for Akai MIDImix.

This happens to be the controller I own myself.

Add mute buttons.

Actually this is mostly because I like being able to press the
mute button on my MIDI controller and have it light up :-)
Internally, it's implemented by forcing the volume to zero
(or sometimes -90 dB), which means we get all the nice
fading properties and such.

In the process, we now declare -90 dB to be truly zero, and don't
bother adding it to the bus.

Fix an issue where silent buses were only partially cleared.

Add scroll bars to the audio strips if needed.

Don't highlight any controllers if no MIDI controller is attached.

Previously, we'd highlight unconditionally as long as we had a
MIDI mapping loaded.

Make the master peak display clickable, like all the other peak labels.

Add support for feedback lights (LEDs) on MIDI controllers.

Add the two final missing MIDI mappings, namely buttons for toggling limiter and auto makeup gain.

Highlight which controllers have currently active MIDI mappings. Very useful with multiple banks.

When having guessed a bus, focus on the next one.

Make sure MIDI mapping extrapolation doesn't give out-of-range values.

Support group-local extrapolation in the MIDI mapping editor.

Make the guess button work.

Right now, it only works across the entire bus; next up will be
group-local extrapolation for the cases where whole-bus extrapolationd
doesn't work.

Implement auto-training controllers in the MIDI input mapping dialog.

Make the save and load buttons in the MIDI mapping edit dialog work.

Add an editor for the MIDI mappings.

Some of the buttons (save, load, guess) are inert, and it doesn't
listen to MIDI events yet.

Listen on all MIDI ports (including hotplug).

It's unlikely that there will be lots of real MIDI note data going on
in the system, so just slurping up all of it seems reasonable
(it's certainly the most user-friendly).

Rewrite the ALSA sequencer input loop.

Seemingly we can get multiple events in one poll, and we can _not_
just go back to polling again (the poll will hang). I consider this
an ALSA bug, but it's easy to work around, the same way aseqdump
does; just set the sequencer to nonblocking and loop over it
until we get EAGAIN.

Add support for controlling the audio using a MIDI controller.

This allows the user to control the audio using a dedicated controller,
as opposed to the mouse, which generally is a more direct and intuitive
user interface.

This is rather raw at the moment (e.g., hardcoded MIDI address, no real UI
indications of bank switches, and no UI for editing the mapping), but the
required basics are generally in place.

Shut down the ALSA inotify thread using an eventfd instead of busypolling every 100 ms.

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.