VL.Audio.BeatNet 0.2.0-alpha

This is a prerelease version of VL.Audio.BeatNet.
dotnet add package VL.Audio.BeatNet --version 0.2.0-alpha
                    
NuGet\Install-Package VL.Audio.BeatNet -Version 0.2.0-alpha
                    
This command is intended to be used within the Package Manager Console in Visual Studio, as it uses the NuGet module's version of Install-Package.
<PackageReference Include="VL.Audio.BeatNet" Version="0.2.0-alpha" />
                    
For projects that support PackageReference, copy this XML node into the project file to reference the package.
<PackageVersion Include="VL.Audio.BeatNet" Version="0.2.0-alpha" />
                    
Directory.Packages.props
<PackageReference Include="VL.Audio.BeatNet" />
                    
Project file
For projects that support Central Package Management (CPM), copy this XML node into the solution Directory.Packages.props file to version the package.
paket add VL.Audio.BeatNet --version 0.2.0-alpha
                    
#r "nuget: VL.Audio.BeatNet, 0.2.0-alpha"
                    
#r directive can be used in F# Interactive and Polyglot Notebooks. Copy this into the interactive tool or source code of the script to reference the package.
#:package VL.Audio.BeatNet@0.2.0-alpha
                    
#:package directive can be used in C# file-based apps starting in .NET 10 preview 4. Copy this into a .cs file before any lines of code to reference the package.
#addin nuget:?package=VL.Audio.BeatNet&version=0.2.0-alpha&prerelease
                    
Install as a Cake Addin
#tool nuget:?package=VL.Audio.BeatNet&version=0.2.0-alpha&prerelease
                    
Install as a Cake Tool

VL.Audio.BeatNet

Real-time beat and downbeat tracking for vvvv gamma and VL.Audio: a C# port of BeatNet, a beat tracker with a neural network and a particle filter. MIT licensed; BeatNet's weights are CC BY 4.0 (see THIRD-PARTY-NOTICES.md).

  • BeatNet node (category Audio.Analysis.BeatTracking): AudioSignal in, Beat (bang), BPM, Phase and Beat Count out; Downbeat and the other bar outputs are optional pins.
  • BeatNet (Detector), BeatScheduler (BeatNet), BeatSchedulerSettings (BeatNet) and BeatNet (Frames) (category Audio.Analysis.BeatTracking): the same, split into BeatNet itself and the part that turns its detections into beats, to compare or patch your own schedulers (see Detector and scheduler). The stable scheduler gives a steadier beat (The stable scheduler), and a tempo lock keeps the tempo found or your own (Tempo lock).
  • BeatActivation (BeatNet) (category Audio.Analysis.Experimental): the raw output of BeatNet's network.
  • Works at 44.1 kHz and 48 kHz. Allocates no memory on the audio thread in steady state.
  • Brings VL.Audio.BeatTracking along (MIT; BeatScaler, BeatInfo, tap tempo): its nodes are available wherever you reference VL.Audio.BeatNet. VL.Audio.BTrack is the other tracker (GPL).
  • The DSP lives in VL.Audio.BeatNet.Core, a plain managed library (netstandard2.1 / net8.0) with no dependencies. Only the thin VL adapter is Windows-specific, because VL.Audio is.

Using it in vvvv

  1. Build the repository: dotnet build -c Release in its root (see the repository README). The assemblies go to lib/net8.0-windows7.0/ of each package.
  2. Make vvvv find the packages: start vvvv with --package-repositories "<repository root>", or add the repository root under Settings > Package Repositories.
  3. Open help/HowTo Track beats with BeatNet.vl, or add the BeatNet node to your own patch.

The trackers

Two nodes use BeatNet (Heydari, Cwitkowitz & Duan, ISMIR 2021), a newer beat tracker with a neural network:

  • BeatNet (category Audio.Analysis.BeatTracking): beats, downbeats, tempo and phase, like BTrack.
  • BeatActivation (BeatNet) (category Audio.Analysis.Experimental): only the network's beat and downbeat probabilities, to look at what BeatNet hears.

help/HowTo Track beats with BeatNet.vl shows the node with a BeatScaler, help/HowTo BeatNet BeatScaler.vl the BeatScaler's scales and taps. help/HowTo Compare BTrack and BeatNet.vl in VL.Audio.BTrack runs both trackers side by side on the same input.

Compared with BTrack:

  • The tempo range is 55–215 BPM, so less music is tracked at half or double tempo. There is no folding.
  • It also detects downbeats and the meter (2, 3 or 4 beats per bar). Bars are less reliable than beats, especially bars of 3; the BeatScaler can count them instead (Beats Per Bar and Tap Downbeat, see pin options).
  • It was trained on mastered music. A loopback device or line input works better than a quiet microphone.
  • About 1 % of one core (Release build). No allocations on the audio thread.
  • Tap Tempo works as on BTrack, but tempi are folded into 55–215 BPM instead of 80–160. No Fixed Tempo.

The BeatNet node

Pin Description
Input Mono AudioSignal. Sum stereo channels first.
Offset (s) Shifts the beat outputs in time, -1 to 1 s. Negative fires predicted beats earlier, to compensate for audio, processing and display latency (effective up to about half a beat). Positive delays all beats, e.g. when the sound reaches the audience later than this input (PA delay, video). Phase and Beat In Bar shift along.
Reset Resets the network's memory and the particle filter.
Tap Tempo Tap at least 4 times on the beat to set the tempo and the beat position. Every further tap refines them; after a pause of 2 s a new series starts. All beat particles move to the tapped tempo and phase, and the beats continue from your last tap; BeatNet keeps following the music afterwards. Useful when it tracks half or double tempo. The tapped beat counts as a downbeat until BeatNet detects one.
Beat True for one frame per beat. Beats are counted on the audio thread, so none get lost.
Downbeat (optional) True together with Beat when the beat is the first of a bar. BeatNet's bar tracking is much less reliable than its beat tracking; treat it as an estimate (Tap Tempo sets the downbeat until BeatNet detects one).
BPM Tempo from the particle filter, 55–215 BPM.
Phase 0 at the beat, rising linearly to 1 one beat period later.
Beat Count Number of beats so far.
Beat Info All beat values in one (Beat, BPM, Phase, Downbeat, Beat Count, Beat In Bar, Beats Per Bar), for a single link to the BeatScaler; Split (BeatInfo) takes it apart. See VL.Audio.BeatTracking.
Beat In Bar (optional) Position of the last beat in its bar: 0 for the downbeat.
Status (optional) Sample rate, window, hop, beats per bar, tap tempo progress, errors.
CPU Load (optional) Processing time on the audio thread as a fraction of real time, over the last second (0–1): 0.01 means 1 % of one core, 1 means the tracker cannot keep up. Wall-clock time; higher in Debug builds.
Beat Activation, Downbeat Activation (optional) The network's probabilities, as on BeatActivation (BeatNet).
Scheduler How BeatNet's detections become beats: Stable (default; a phase-locked loop for a steady beat, see The stable scheduler), Predictive (follows every detection, see below), Reactive (exactly BeatNet's detections, late and with gaps; for comparison) or Custom (the settings at the Settings pin; see Scheduler settings). Switching between Predictive, Stable and Custom keeps the beats running; to or from Reactive restarts them.
Settings (optional) Settings from a BeatSchedulerSettings (BeatNet) node; used only with Scheduler = Custom.
Lock Found BPM Locks the tempo on the tempo found, see Tempo lock.
Lock User BPM, User BPM, Tempo Range (Percent) (optional) The rest of the tempo lock, see Tempo lock.
Lock Status What the tempo lock is doing.
Locked Tempo (optional) Centre of the tempo lock (0 while the tempo is free).
Report Narrow Peaks (optional) Default on: also reports beats whose activation peak is only one frame (20 ms) wide, as sharp kicks often are. Off: as the original BeatNet, which loses them (see Deviations from the original further down). Switches without a restart, for comparison.

The BeatScaler works below it, as below BTrack.

Pin options shows, with illustrations, what problem each option solves.

Detector and scheduler

BeatNet detects a beat only after it happened, and misses some. Turning its detections into beats is a separate step, the scheduler, which is not part of BeatNet. To compare schedulers or patch your own, the BeatNet node also exists in two parts:

  • BeatNet (Detector): BeatNet itself. Its Detector output is a reference to BeatNet's frames (one every 20 ms, the last 10 s kept) and to the audio clock. Also BPM, Beats Per Bar, activations, Status, CPU Load; inputs Reset, Tap Tempo and Report Narrow Peaks (optional, as on the BeatNet node). Two detectors on the same input, one with Report Narrow Peaks off, compare the original BeatNet with the change (as in the help patch).
  • BeatScheduler (BeatNet): Detector in; Beat, BPM, Phase, Beat Count and Beat Info out, Downbeat, Beat In Bar, Beats Per Bar and Confidence as optional pins. Scheduler chooses Predictive, Reactive, Stable or Custom, and Settings takes the settings for Custom; Offset and Reset as usual; the tempo lock pins with Locked Tempo and Lock Status. Each scheduler reads the frames it has not seen yet directly from the detector, without allocating, so several schedulers can follow one detector.
  • BeatSchedulerSettings (BeatNet): all settings of the predicting scheduler as pins (Scheduler settings), for the Settings pin of BeatScheduler (BeatNet) or BeatNet with Scheduler = Custom. With its defaults it is exactly Predictive. It creates new settings only when a value changes.
  • BeatNet (Frames): Detector in; the frames since the previous mainloop frame as a Spread of BeatNetFrame, plus Current Sample (the audio clock, extrapolated between audio buffers) and Sample Rate, to patch your own scheduler. Each frame has Index, Centre Sample, Completed Sample, Beat/Downbeat Activation, Tempo, Beats Per Bar, Detection (None, Beat, Downbeat; also Is Detection, Is Downbeat), Beat In Bar, and Tapped Beat Sample / Tapped Tempo (set once after Tap Tempo). This node allocates a Spread when there are new frames (about 50 small arrays per second); the scheduler nodes do not.

help/HowTo BeatNet Schedulers.vl shows the detector with several schedulers side by side, with presets and with custom settings from a settings node, next to the BeatNet node.

The scheduler runs on the mainloop here, not on the audio thread: it sees the frames one mainloop frame later, but times the beats with the audio clock, so the beats are the same (tested: within 10 ms) and fire at most one frame later than in the BeatNet node. A detection's sample is its frame's Centre Sample; the frame is complete 32 ms later.

In C#, BeatNetDetector delivers the frames and IBeatScheduler turns them into beats: AdvancedBeatScheduler (Predictive with its defaults or ApplyPredictivePreset(), Stable with ApplyStablePreset(), the lock in TempoLock) and ReactiveBeatScheduler. BeatSchedulers.Create(kind, rate) makes either, and BeatNetTracker combines a detector with one.

Scheduler settings

Predictive, Stable and Custom are one implementation, AdvancedBeatScheduler. Its settings are the pins of BeatSchedulerSettings (BeatNet): set Scheduler = Custom and connect the node to the Settings pin of BeatScheduler (BeatNet) or BeatNet. Each setting has no effect at its default, so the defaults give exactly the Predictive scheduler, and acts only once it is changed. All settings can change while the beats run.

Setting Default (no effect) Stable Description
Phase Gain 1 0.3 How far a detection pulls the beats towards itself (0.01–1). 1 jumps to every detection, with BeatNet's jitter of about 20 ms. Smaller is steadier but follows real changes more slowly. Automatically higher while Confidence is low (at the start, after a change).
Tempo Correction off on Learns the tempo from deviations that keep coming back the same way: BeatNet only knows the tempo roughly, because it counts beat periods in whole frames. Useful with Phase Gain below 1, which otherwise leaves a constant lag. Acts only with Tempo Smoothing > 0: with 0, BeatNet's tempo replaces the corrected one every frame. The smoothing still pulls towards BeatNet's tempo, so a lag is reduced, not always removed.
Rephase After 1 2 Detections in a row, more than a quarter beat off the beats, that must agree before the beats move to them. Fewer are ignored, e.g. a loud offbeat.
Max Correction 0 (off) 0.1 Largest change of the interval between two beats, as a fraction of a beat (0–0.5). A move is spread over several beats instead of a stumble. With Late Beats on, a detection off the beats is still fired at once.
Tempo Smoothing (s) 0 2 Time constant with which the tempo follows BeatNet's tempo once the beats are confirmed; faster while they are not.
Octave Hold (s) 0 1.5 How long BeatNet must report double or half the tempo before the beats follow; shorter jumps are folded back. Then the beats go straight onto the new grid.
Hold Beats 8 16 Beats predicted without a detection before the output stops (e.g. a break). With a phase-locked setting (Phase Gain, Tempo Correction, Rephase After or Max Correction changed), the beats continue on the old grid when the detections return.
Bar Hold 1 4 Detections in a row that must agree on another bar position or meter before the beat count follows BeatNet.
Late Beats on off Fires a detection that was not predicted at once, late. Off: the beats wait for the next predicted beat.

How the settings divide the work, at 120 BPM (a beat every 500 ms):

  • Phase Gain handles small deviations of a detection from the beat, up to ¼ beat. With 1, a detection 20 ms late moves the beats by 20 ms. With 0.3 it moves them by 6 ms, and random one-frame errors average out.
  • Rephase After handles large deviations, more than ¼ beat. With 1, a single detection between two beats moves the beats to the offbeat. With 2, it is ignored unless the next detection agrees.
  • Tempo Correction turns deviations that keep coming back the same way into a tempo correction (together with Tempo Smoothing).

Confidence (optional output of BeatScheduler (BeatNet), 0–1) tells how well BeatNet's detections confirm the beats. It rises with every confirmed beat, falls with every beat without a detection, and is 0 when the output has stopped.

The stable scheduler

The predictive scheduler passes BeatNet's jitter straight to its output:

  • it snaps to every detection, and detections come on a 20 ms frame grid;
  • it takes the particle filter's tempo every frame, which jumps because the filter counts beat periods in whole frames;
  • it fires every detection off the predicted beat as an extra beat;
  • it takes BeatNet's bar position from every detection.

The stable scheduler (Scheduler = Stable, or Custom with the values of the "Stable" column above) is a phase-locked loop (an alpha-beta filter) on BeatNet's detections. It predicts and fires beats like the predictive scheduler, a negative Offset included.

Measured with btrack beatnet --metrics --truth on 17 synthetic signals at 44.1 kHz, 30–40 s each, after the first 5 s. The signals are the 8 drum loops above plus 9 harder ones: noise with ghost notes, a break, syncopation, an accelerando 100→130 BPM, swing, half-time feel, house with offbeat bass, humanised timing, and a tempo change 120→95 BPM. Predictive and stable scheduler with default settings:

Predictive Stable
Jitter (RMS change of the interval from beat to beat) 3.5 % 2.0 %
Stumbles (interval < ¾ of the local beat) 6 0
Gaps (interval > 1½ of the local beat) 4 2
Tempo octave flips 4 2
Bar position jumps 413 148
F-measure (±70 ms), mean 0.930 0.920
Mean timing error of correct beats 7.5 ms 6.3 ms
  • The stable scheduler is steadier everywhere. It is more accurate on noise, breaks and half-time feel.
  • It is less accurate where the music changes abruptly. It moves to a new tempo gradually and keeps beating meanwhile; the predictive scheduler jumps:
    • 120→95 BPM: F 0.87 against 0.91;
    • 120→140 BPM: 0.88 against 0.93;
    • the accelerando: 0.83 against 0.90.
  • On the 110 BPM loop the start costs it: 0.88 against 0.97. BeatNet's first detection comes with a wrong tempo, and the predictive scheduler happens to land on the beat sooner.
  • Higher Phase Gain and lower Tempo Smoothing make it follow faster, at the cost of steadiness.
  • Synthetic signals are not music. Compare the schedulers on your own material, in help/HowTo BeatNet Schedulers.vl.

Tempo lock

For music with a steady tempo, the tempo lock confines the tempo to a narrow range around a centre. It works with Predictive, Stable and every Custom setting. Reactive has no tempo of its own and ignores it. It is on BeatScheduler (BeatNet) and on the BeatNet node (there Lock Found BPM and Lock Status are shown, the other lock pins are optional).

Pin Default Description
Lock Found BPM off Locks on the tempo found. It is captured once 8 detections in a row confirm the beats (no move to a new grid or tempo octave in between); switched on in the middle of a song, that is usually at once. Tap Tempo on the detector sets it too. Overrides Lock User BPM. Switch it off and on again, or Reset, to capture anew.
Lock User BPM off Locks on User BPM. While Lock Found BPM is still waiting for confirmed beats, the user tempo is used meanwhile.
User BPM 120 Centre for Lock User BPM (50–230).
Tempo Range (Percent) 3 How far the tempo may move from the centre.
Locked Tempo (output) The centre in BPM, 0 while the tempo is free.
Lock Status (output) off, waiting for the beat (5 of 8 detections), locked on found tempo 127.8 BPM ±3 %, locked on user tempo 128.0 BPM ±3 %, with , music outside the range while BeatNet's tempo has been outside the range for half a second, or not available for the Reactive scheduler.

While locked:

  • BeatNet's tempo is folded to the octave of the centre and clipped to the range. Jumps to double or half tempo are therefore impossible.
  • The tempo follows it only with Tempo Smoothing, not faster when Confidence is low.
  • Tempo Correction corrects the tempo only with Phase Gain, so it can't move further than the range either.
  • The beat position still follows the detections.

Measured as above, Stable with Lock Found BPM:

  • Steady signals: at least as good as without the lock. Half-time feel improves from F 0.94 to 0.98 (longest correct stretch 33 % → 98 %). The break: jitter 2.8 % → 0.9 %.
  • Where the tempo really changes, it deliberately stays:
    • 120→95 BPM: F 0.58;
    • 120→140 BPM: 0.52;
    • accelerando: 0.40.
  • Wrong octave at the start: if BeatNet starts at double tempo (the accelerando, the 100 BPM loop), the lock captures that. Lock User BPM or Tap Tempo set the right centre.

How it works:

  1. Network (BeatNet's first stage). Every 20 ms a 64 ms window is analysed:
    • a logarithmic spectrogram with 136 bands, plus its positive difference to the previous frame (272 values);
    • a small convolution layer, a 2-layer LSTM with 150 cells, and a softmax over beat, downbeat and no beat. A frame is complete 32 ms (half a window) after the moment it describes.
  2. Particle filter (BeatNet's second stage):
    • 1500 particles move through beat positions at 42 beat periods (14–55 frames);
    • 250 particles move through the beats of bars of 2, 3 or 4 beats. The network's output reweights them every frame. BeatNet reports a beat once the particle cloud has passed it, that is after the beat.
  3. Beat scheduler (added for live use; exchangeable, see Detector and scheduler). The predictive scheduler predicts the next beat from the last detected beat and the tempo, and fires it on time, or earlier by a negative Offset. A detected beat within a quarter beat of a fired one only corrects the timing; a detected beat that was not predicted is fired at once (late). Without detections, for example in silence, at most 8 beats are predicted. The stable scheduler is a steadier alternative, and every step can be tuned (see Scheduler settings and The stable scheduler).

Deviations from the original:

  • Particle count. In BeatNet, the particles added on strong activations are never removed (the result of np.delete is discarded), so their number grows without bound: 1745 instead of 1500 after 30 s. The port resamples back to 1500 and 250. On the test loops this changes nothing measurable.
  • Random numbers. The port uses its own seeded generator (deterministic, the same on every platform). Results equal the original only statistically.
  • Narrow activation peaks are reported (on by default; the pin Report Narrow Peaks and ReportWindow on the detector class restore the original).
    • The problem: the particles line up with an activation peak in one frame, but BeatNet can only report the beat in the following frames, and only if the activation there is still above 0.4. A sharp kick whose peak is a single frame wide (0.97, then 0.3) is therefore never reported. Which kicks land like that depends on how the 20 ms frames fall on the music, so it changes with the start of playback. On one song BeatNet reported only 37–75 of its 148 beats, with gaps of up to 39 s, depending on the start (shifted by 0–17.5 ms).
    • The change: a beat is judged by the frame with the highest activation since the particles passed the beat. The bar stage (downbeats) is weighted with that frame's activations too. A beat is never reported later than in the original.
    • Results on the 17 test signals, 8 seeds each, compared with the original:
      • reported beats (Reactive scheduler): F-measure 0.79 → 0.94, gaps 875 → 111;
      • Predictive: F unchanged (0.92), gaps 43 → 10, stumbles 66 → 42, jitter 3.8 → 3.0 %;
      • Stable: F unchanged (0.91), gaps 15 → 3, but more bar jumps (1374 → 1837), because the stable scheduler now gets enough detections to follow BeatNet's bar position more often;
      • on the song above, 147–152 beats reported at every start, longest gap 1.9 s.
  • Scheduler and tap tempo. Neither is part of BeatNet.

Fidelity

Network:

  • At 22.05 kHz (BeatNet's own rate) the C# code reproduces the original Python implementation within float precision: features within 2·10⁻⁷ of madmom, activations within 1·10⁻⁶ of PyTorch. The tests check this against reference data in tests/VL.Audio.BeatNet.Core.Tests/TestData.
  • At 44.1 and 48 kHz the features are computed at the native rate, without resampling:
    • window 2822 / 3072 samples, hop 882 / 960;
    • only the bins below 11.025 kHz, which is what a 22.05 kHz signal contains;
    • the activations correlate at 0.99 with those of the same signal rendered at 22.05 kHz.

Particle filter: compared with the Python original on synthetic drum loops (30 s each), without the report window (Report Narrow Peaks off). The values are the beat F-measure (±70 ms, after 5 s), averaged over 10 seeds; in brackets, at the best metrical level.

Loop Python, detections C#, detections C#, scheduled beats (22.05 / 44.1 / 48 kHz)
90 BPM 0.71 0.69 0.66 (0.98) / 0.96 / 0.94
120 BPM 0.70 (0.96) 0.70 (0.96) 0.99 / 0.99 / 0.95
140 BPM 0.74 0.71 0.98 / 0.99 / 0.99
170 BPM 0.57 (0.89) 0.58 (0.89) 0.66 (0.99) / 0.66 (0.99) / 0.66 (0.98)
120 → 140 BPM 0.68 0.67 0.89 / 0.90 / 0.88
  • The detections agree with the original within the variation between seeds.
  • BeatNet itself misses many beats on these loops, or tracks half tempo; the scheduler fills them in. Many of the missed beats are narrow activation peaks, which the report window catches.
  • BTrack gets 1.0 on the same loops (170 BPM at half tempo). Synthetic drum loops are its best case, and far from the music BeatNet was trained on. Compare the two on real music.

Repository layout

src/VL.Audio.BeatNet.Core/   port of BeatNet: features, network, embedded weights (beatnet_model_1.bin), particle
                   filter, BeatNetDetector (network + particle filter, frames), BeatSchedulers (IBeatScheduler,
                   kinds, reactive), AdvancedBeatScheduler (predictive and stable), TempoLock, BeatNetTracker (detector
                   + scheduler); namespace VL.Audio.BeatNet
src/VL.Audio.BeatNet/        VL adapter: BeatNetNode, BeatNetDetectorNode, BeatSchedulerNode,
                   BeatSchedulerSettingsNode, BeatNetFramesNode and Experimental/BeatActivationNode ([ProcessNode]);
                   BeatSchedulerRunner (mainloop side of the scheduler nodes), TempoLockPins (lock pins, Lock Status);
                   BeatNetFrontEnd and BeatNetSignal (VL.Audio SinkSignal); BeatNetFrameRing keeps the frames for the main
                   thread (BeatNetDetectorState)
tests/VL.Audio.BeatNet.Core.Tests/   unit tests (TestData/: BeatNet reference data)
tests/VL.Audio.BeatNet.Tests/        integration test that drives VL.Audio's real audio callback without vvvv
VL.Audio.BeatNet.vl          VL document (package entry point)
help/              help patches (the BeatNet node; the detector with several schedulers; the BeatScaler)

dotnet test in this folder runs its tests (they use files of VL.Audio.BeatTracking next to it).

Licence

MIT (see LICENSE.txt). The C# port includes BeatNet (CC BY 4.0) and algorithms of madmom (BSD); see THIRD-PARTY-NOTICES.md. If you use it in research, please cite the BeatNet paper given there.

Product Compatible and additional computed target framework versions.
.NET net8.0-windows7.0 is compatible.  net9.0-windows was computed.  net10.0-windows was computed. 
Compatible target framework(s)
Included target framework(s) (in package)
Learn more about Target Frameworks and .NET Standard.

NuGet packages (1)

Showing the top 1 NuGet packages that depend on VL.Audio.BeatNet:

Package Downloads
VL.Audio.BTrack

Real-time beat tracker node for vvvv gamma and VL.Audio, working at 44.1 and 48 kHz: a C# port of BTrack by Adam Stark (Queen Mary University of London). Licensed GPL-3.0-or-later, as BTrack requires: patches that use it fall under the GPL. Brings the BeatScaler of VL.Audio.BeatTracking and, for its comparison help patch, VL.Audio.BeatNet along.

GitHub repositories

This package is not used by any popular GitHub repositories.

Version Downloads Last Updated
0.2.0-alpha 63 11/15/2026