Repository files navigation

GitLab |GitHub |Principal author's website

Highly experimental for now. I don't recommend using it for serious purposes.

However, chances that it'll break already working Dante network are low.

Big thanks toProject Pendulum (byTrifecta Tech Foundation) for creating and maintainingStatime and collaboration on features needed for audiovisual networks functionality! Audio transmission would be much more difficult to implement without it.

Respect to the engineers at Audinate for well-designed protocol and robust hardware devices, but the suits that decided to keep the protocol secret, ignore FOSS community and paywall a device driver should go to...Inferno!

• receiving audio from and sending audio to Dante devices and virtual devices
• connections can be made using Dante Controller ornetwork-audio-controller (netaudio command line tool)

• ✅ - usable
• 💣 - experimental
• ☑️ - not a part of this software but integration is easily possible
• ⏳ - will be implemented soon (until 2025-06 probably)
• 🚫 - unimplemented and not planned for the near future

• Dante protocol is undocumented. Everything was reverse-engineered or based on other reverse-engineering projects. Some things in implementation were guessed. So while it works with my setup, it may not work with yours.
• Inferno2pipe is clocked by incoming media flows. When nothing is connected, "time will stop" (i.e. recording will pause) until something is connected again - silence won't be generated unless at least one channel is connected.

1. Install Rust
2. If using a firewall, open UDP ports: 4455, 8700, 4400, 8800 (or others ifINFERNO_ALT_PORT is specified), 5353. Also, allow incoming UDP traffic from possible transmitters (port numbers are allocated by the OS so can't be known beforehand)
3. If wanting to use anything other than Inferno2pipe, clock synchronization daemon is needed. Inferno is compatible with modifiedStatime:
   • currently, Statime is always needed, even for just capturing audio, but it is not by design and will be fixed
   • git clone --recurse-submodules -b inferno-dev https://github.com/teodly/statime
   • cd statime && cargo build
   • adjust network interface ininferno-ptpv1.toml
   • sudo target/debug/statime -c inferno-ptpv1.toml
4. Clone this repo with--recursive option (some dependencies are in submodules)
5. cd to the desired program/library directory
   • simple command line audio recorder:Inferno2pipe
   • virtual soundcard for ALSA:alsa_pcm_inferno - also works with PipeWire, should work with JACK (not tested yet)
6. cargo build
7. Follow the instructions in README of the specific program/library

Disclaimer: Dante uses technology patented by Audinate. This source code may use these patents too. Consult a lawyer if you want to:

• make money of it
• distribute binaries in (or from) a region where software patents apply

This project makes no claim to be either authorized or approved by Audinate.

Please do not use this project to make counterfeit Dante devices/software, it is both immoral and illegal (while Audinate's approach is only immoral). Always specify that the implementation is unofficial and not endorsed by Audinate. Probably you can legally say that it is compatible with a subset of Dante protocol, but IANAL.

This project is dual licensed under the GPLv3-or-later and AGPLv3-or-later. You may choose which license to use, or retain both. For example:

• if you want to integrate it into a project already licensed under the GPL, you have the rights to do so.
• if you want to fork it into something working in cloud (or public Internet in general), it will be beneficial to the Free Software Community to use the AGPLand remove GPL when forking.

• Audinate AVIO AES3
• Audinate AVIO-DAI2
• Ben & Fellows 523019 4x4 balanced analog I/O module (based on Dante UltimoX4)
• Klark Teknik DN32-DANTE (Behringer X32) (based on Dante Brooklyn II)
• Soundcraft Vi2000 & Vi3000
• Allen&Heath SQ-5 & SQ-6
• ESI planet 22c
• Dante Via @ OS X
• Dante Virtual Soundcard @ Windows 10

• Dante Controller @ Windows 10, 11
• network-audio-controller

• x86_64 Linux
  • Arch
  • Ubuntu
  • Fedora
• aarch64 (ARM 64-bit) Linux @ Raspberry Pi 5
  • Raspberry Pi OS
  • Armbian Bookworm

• inferno_aoip - main library crate for emulating a Dante audio over IP device. In the future controller functionality will also be implemented.Start here if you want to develop your app based on Inferno.
• inferno2pipe - capture audio, writing interleaved 32-bit integer samples into an Unix named pipe (or a raw file). Helper script for recording to more convenient format is also provided.Start here if you want to use Inferno for capturing audio without setting up whole audio stack
• alsa_pcm_inferno - virtual soundcard for ALSA.Start here if you've ever dreamed of Dante Virtual Soundcard for Linux
• searchfire - fork ofSearchlight mDNS crate, modified for compatibility with Dante's mDNS

Configuration can be set via:

• environment variables - addINFERNO_ prefix to the setting name
• ALSA plugin configuration - it is recommended to specify them in yourasoundrc because too long ALSA device string may be truncated (happens with PipeWire, not sure about other apps)

• BIND_IP - which local IP to bind to. Specifying it may be necessary if you have multiple network interfaces
• DEVICE_ID - 16 hexadecimal digits (8 bytes) used as a device ID. Dante devices usually use MAC address padded with zeros. Inferno uses0000<IP address>0000 by default. Device ID is the storage key when saving state.
• NAME - name of advertised device. If unspecified, name based on app name and IP address will be generated. May be removed in future versions when it becomes settable from DC and so stored in a configuration file.
• SAMPLE_RATE - sample rate this device will operate on
• PROCESS_ID - integer number between 0 and 65535. Must be provided and unique when starting multiple instances on a single IP address. Specifying differentDEVICE_IDs is not sufficient.
• ALT_PORT - start of the range of UDP ports used by socket listeners. If not specified, standard Dante ports as seen in hardware devices will be used. Must be provided when starting multiple instances on a single IP address. Currently 4 ports are used (ALT_PORT toALT_PORT+3) but it may change in the future, so better separate different instances by at least 10 ports.
• RX_CHANNELS - number of receive channels, defaults to 2, will be overwritten by the application if it supports changing channels count.
• TX_CHANNELS - number of transmit channels, defaults to 2, will be overwritten by the application if it supports changing channels count.
• RX_LATENCY_NS - receive latency in nanoseconds, i.e. how much time to wait for media packets, relatively to PTP media clock. Equivalent to latency setting in Dante Controller. Defaults to 10ms. May be removed in future versions when it becomes settable from DC and so stored in a configuration file.
• TX_LATENCY_NS - transmit latency in nanoseconds, i.e. receive latency that this device will demand from devices receiving from us. Equivalent to latency setting in Dante Virtual Soundcard. Defaults to 10ms.

Issue reports and pull requests are welcome.

By submitting any contribution, you agree that it will be distributed according to the comment found at the top ofinferno_aoip/src/lib.rs file - under the terms of GNU GPL v3 or any later version, or GNU AGPL v3 or any later version.

If you want to fork this project into something working in cloud (or public Internet in general), you may consider removing the GPL license and retaining AGPL.

Please use editor respecting.editorconfig (for example, VSCode needs an extension:EditorConfig for VS Code) or configure it approprietly manually.

• changeable RX & TX channel names
• RX & TX latency configurable via env var or ALSA plugin parameter
• relicense to GPL-or-AGPL to simplify forking to AGPL projects, as parts of this project may be useful in cloud applications

• read configuration from ALSA plugin parameters - useful for multiple sources & sinks in PipeWire
• send statistics (clock, latency, signal levels)
• changeable usrvclock path

• introduced ALSA PCM plugin - a virtual soundcard compatible with most Linux audio apps
• receive clock using a documented protocol:usrvclock
• various internal changes primarily related to allowing the use of external buffers (needed for mmap mode in ALSA plugin)
• receive multicasts
• ability to use non-default network ports to allow running multiple instances on a single IP address
• removed Inferno Wired because the ALSA plugin works well with PipeWire.This is the last version for the curious.

• audio transmitter
• alpha version of Inferno Wired - virtual audio source & sink for PipeWire
• receiving clock fromStatime modified for PTPv1 and virtual clock support - Linux-only for now (because CLOCK_TAI is Linux-only)
• increased receive thread priority to reduce chance of OS UDP input queue overflow

initial release

likely in order they'll be implementated

• ability to change settings in Dante Controller
• transmit multicast flows

At this point, Inferno will roughly become alternative to Dante Virtual Soundcard.

• read configuration from text files
• ability to work as a clock source (PTP leader)
• automated integration test that will launch several instances, stream audio data between them and check for its correctness
• bit-perfect transmitter (currently 32-bit integers are always used internally and conversion to 24-bit or 16-bit adds dither)
• API: number of channels changeable without device server restart (useful for Dante Via-like operation where transmitters & receivers can be added and removed dynamically)
• AES67
• primary & secondary network support, for dual-NIC computers
• grep -r TODO inferno_aoip/src

• 99% safe Rust (unsafe is required only because ALSA plugin API doesn't have safe Rust bindings)
• no external libraries needed, the only dependencies are Rust crates

I've been using free as in freedom, open source software for many years now. I'm also fascinated by connections between music and technology. One day my sound engineer collegue showed me how Dante works, how easy to use and (most of the time) stable it is. The problem was that it's not an open standard, didn't have open source implementation and I couldn't use it on my favourite operating system - Linux. Now I can.

• AES67 is only a standard of media transport, not control, so flows need to be established manually. NMOS could fix it but I doubt Audinate will implement it in reasonable future.

And the following are limitations of AES67 implementation in Dante, not AES67 in general:

• it is not supported in Dante Virtual Soundcard and Dante Via
• some older Dante devices (without firmware upgrades) don't support it either
• it is multicast-only
• sample rate is locked to 48kHz

• network-audio-controller - command line connection and device controller, alternative to Dante Controller
• dante-aes67-relay.js - Relay a Dante multicast stream to AES67
• wycliffe, receiver implementation contained in a video control software
• List of AES67 audio resources atAES67 Stream Monitor website (Dante is AES67-compatible but not on all devices and requires manual configuration)

To my knowledge, there are no other unofficial implementations of audio transmission compatible with Dante. However, if AES67 fits your use case, you may want to use:

• AES67 Linux daemon with kernel-level virtual soundcard
• pipewire-aes67
• aes67-recorder (tutorial for usage with Dante)
• AES67 can be also received by any software that supports raw audio in RTP packets, e.g. FFmpeg or GStreamer.