(c) 2016 Jean-Luc Deltombe LX3JL and Luc Engelmann LX1IQ

The XLX Multiprotocol Gateway Reflector Server is part of the software system for the D-Star Network. The sources are published under GPL Licenses.

• D-Star: Icom-G3Terminal, DExtra, DPlus and DCS
• DMR: DMRPlus (dongle) and DMRMmdvm
• C4FM: YSF, YSF Client, Wires-X and IMRS
• NXDN: NXDN Reflector Peering (peer-only, same AMBE2+ codec as DMR - no transcoding needed)
• P25: P25 Reflector Peering (peer-only, IMBE codec - requires AMBEd software transcoding)
• REF: REF/DPlus Reflector Peering (peer-only, same AMBE+ codec as D-Star - no transcoding needed)
• XRF: XRF/DExtra Reflector Peering (peer-only, same AMBE+ codec as D-Star - no transcoding needed)
• DCS: DCS Reflector Peering (peer-only, same AMBE+ codec as D-Star - no transcoding needed)
• M17: Full M17 protocol support with Codec2 software transcoding
• XLX Interlink: Protocol for linking reflectors (revision 3 with M17 Codec2 support)

XLX reflectors can peer with each other to share voice traffic. The interlink protocol has evolved to support multiple codecs:

When two XLX reflectors connect, they exchange version numbers. The sending reflector checks the receiver's version and sends the appropriate packet size:

• Receiver < 2.2.0: Receives 27-byte packets (D-Star only)
• Receiver 2.2.0 - 2.5.x: Receives 45-byte packets (D-Star + DMR)
• Receiver 2.6.0+: Receives 53-byte packets (D-Star + DMR + M17)

When two XLX reflectors running v2.6.0+ are peered:

1. No M17 Transcoding Required: M17 Codec2 audio passes directly between reflectors
2. Reduced CPU Load: Eliminates encode/decode cycles for M17 traffic
3. Lower Latency: Direct codec passthrough instead of transcoding chain
4. Full Backward Compatibility: Older reflectors still work (receive appropriate subset)

Revision 3 DV Frame Packet (53 bytes):
┌───────────────────────────────────────────────────────────────────────────┐
│ DSVT Header (12) │ StreamID (2)  │ PacketID (1) │ AMBE (9)   │ DVData (3) │
├───────────────────────────────────────────────────────────────────────────┤
│ DMR_PktID (1)    │ DMR_SubID (1) │ AMBE+ (9)    │ DVSync (7) │ Codec2 (8) │
└───────────────────────────────────────────────────────────────────────────┘
         └── Rev 0/1: 27 bytes ──┘                          │
         └────────── Rev 2: 45 bytes ───────────────────────┘
         └────────────── Rev 3: 53 bytes ───────────────────────────────┘

XLX001 (v2.6.0)                              XLX002 (v2.6.0)
      │                                            │
      │◀── Protocol Rev 3 (53-byte packets) ──────▶│
      │                                            │
  ┌───────┐                                    ┌───────┐
  │  M17  │ ◀─── Codec2 passthrough ──────────▶│  M17  │
  │ Client│     (no transcoding needed)        │ Client│
  └───────┘                                    └───────┘

If you are upgrading to XLX v2.6.0 or later, you MUST also update your AMBEd (AMBE transcoder daemon).

AMBEd v1.4.0 includes:

• Codec2 software vocoder for M17 transcoding (encode and decode)
• IMBE software vocoder for P25 transcoding (encode and decode)
• Multi-codec response protocol supporting up to 3 output codecs per stream
• Dynamic max concurrent streams calculated from available hardware channels
• DSCP/QoS marking for voice packets (configurable, default EF/46)
• Byte-order fix for DVSI hardware PCM output

1. Update XLX:

   cd xlxd
   git pull
   cd src && make clean && make && make install

2. Update AMBEd:

   cd xlxd/ambed
   make clean && make && make install

3. Restart both services:

   systemctl restart ambed
   systemctl restart xlxd

DMR, YSF, and NXDN all use the same AMBE+2 codec but with different audio level conventions. XLX automatically adjusts gains when bridging between these modes to provide consistent audio levels.

Current gain adjustments (configured in main.h):

This adjustment is performed in the AMBE+2 bitstream by modifying the b2 voice parameter, which requires:

1. Golay FEC decoding to extract voice parameters
2. Modification of the 5-bit b2 gain index
3. PRNG re-scrambling with the updated parameters
4. Golay FEC re-encoding

The adjustment is applied once at the reflector level, providing consistent audio levels for all users without requiring individual radio configuration changes.

This version of XLX includes full M17 digital voice protocol support with bidirectional transcoding to all other supported modes.

• Full M17 Protocol Implementation: Native M17 reflector connectivity on UDP port 17000
• Hybrid Transcoding: M17↔DMR/YSF uses software only; M17↔D-Star uses software + hardware chain
• Bidirectional Audio: M17 users hear all other users (DMR/D-Star/YSF), and vice versa
• Dual Identity: Reflector responds to both XLX-xxx and M17-xxx callsigns
• Module Support: Full A-Z module mapping
• Quality Optimized: Uses AMBE2+ as intermediate codec for better audio quality

M17 transcoding uses DVSI hardware via AMBEd for all paths:

• M17 → D-Star/DMR/YSF: Codec2 decode (software in ambed) → PCM → AMBE encode (hardware)
• D-Star/DMR/YSF → M17: AMBE decode (hardware) → PCM → Codec2 encode (software in ambed)

┌─────────────────────────────────────────────────────────────────────────────┐
│                    M17 ↔ DMR/D-Star Transcoding (via AMBEd)                 │
├─────────────────────────────────────────────────────────────────────────────┤
│                                                                             │
│   M17 Client                    AMBEd                      DMR/D-Star       │
│   (Codec2)                   (transcoder)                   (AMBE)          │
│        │                          │                           │             │
│        ▼                          ▼                           ▼             │
│   ┌─────────┐              ┌─────────────┐              ┌─────────┐         │
│   │ Codec2  │─────────────▶│   Codec2    │              │  AMBE   │         │
│   │  Frame  │              │   Decode    │─────────────▶│  Frame  │         │
│   │(8 bytes)│              │  (software) │   DVSI HW    │(9 bytes)│         │
│   └─────────┘              │      ↓      │   Encode     └─────────┘         │
│                            │     PCM     │                                  │
│   ┌─────────┐              │      ↓      │              ┌─────────┐         │
│   │ Codec2  │◀─────────────│   Codec2    │              │  AMBE   │         │
│   │  Frame  │              │   Encode    │◀─────────────│  Frame  │         │
│   │(8 bytes)│              │  (software) │   DVSI HW    │(9 bytes)│         │
│   └─────────┘              └─────────────┘   Decode     └─────────┘         │
│                                                                             │
│                        USES DVSI HARDWARE CHANNELS                          │
└─────────────────────────────────────────────────────────────────────────────┘

• Port: UDP 17000
• Keepalive: PING/PONG every 5 seconds
• Timeout: 35 seconds without PONG
• Frame Size: 54 bytes (including "M17 " magic)
• Voice Codec: Codec2 3200bps (8 bytes per 20ms frame)
• Callsign Encoding: Base-40 (9 characters in 6 bytes)

// M17 Protocol Settings
#define M17_PORT                17000   // UDP port
#define M17_KEEPALIVE_PERIOD    5       // seconds
#define M17_KEEPALIVE_TIMEOUT   35      // seconds

// Codec identifier
#define CODEC_CODEC2            3       // M17 uses Codec2

M17 transcoding uses software Codec2 plus DVSI hardware for AMBE:

Example with 6 DVSI channels:

• DMR ↔ D-Star: Uses 2 hardware channels per simultaneous stream
• M17 ↔ any: Uses 1 hardware channel per stream (Codec2 is software)

The packages which are described in this document are designed to install server software which is used for the D-Star network infrastructure. It requires a 24/7 internet connection which can support 20 voice streams or more to connect repeaters and hotspot dongles.

• The server requires a fixed IP-address
• The public IP address should have a DNS record which must be published in the common host files

If you want to run this software please make sure that you can provide this service free of charge, like the developer team provides the software and the network infrastructure free of charge!

The software packages for Linux are tested on Debian 7 (Wheezy) 32 and 64bit or newer. Raspbian will work but is not recommended. Please use the stable version listed above, we cannot support others.

apt-get update
apt-get upgrade

apt-get install git git-core
apt-get install apache2 php
apt-get install build-essential

git clone https://github.com/LX3JL/xlxd.git
cd xlxd/src/

nano main.h

Important settings to check:

• NB_OF_MODULES - Number of modules (default 10, max 26)
• YSF_DEFAULT_NODE_TX_FREQ / YSF_DEFAULT_NODE_RX_FREQ - YSF frequencies
• M17 clients must specify a valid module (A-Z)

make clean
make
make install

cp ~/xlxd/scripts/xlxd /etc/init.d/xlxd
nano /etc/init.d/xlxd  # Adapt parameters to your needs
update-rc.d xlxd defaults

wget -O /xlxd/dmrid.dat http://xlxapi.rlx.lu/api/exportdmr.php

Follow the readme in the AMBEd directory for FTDI driver and AMBE service setup.

service xlxd start
service xlxd stop

cp -r ~/xlxd/dashboard /var/www/db
chmod +r /var/log/messages

reboot

XLX Server requires the following ports to be open and forwarded properly:

M17 clients can connect using:

• Reflector callsign: M17-XXX or XLX-XXX (where XXX is your reflector ID)
• Module: A-Z (must be specified, invalid modules rejected)
• Port: 17000/UDP

Client                              Reflector
   |                                    |
   |-------- CONN (callsign) ---------->|
   |                                    |
   |<--------- ACKN / NACK -------------|
   |                                    |
   |<---------- PING -------------------|
   |                                    |
   |----------- PONG ------------------>|
   |           (every 5s)               |
   |                                    |
   |-------- Voice Frames ------------->|
   |<------- Voice Frames --------------|
   |                                    |
   |---------- DISC ------------------->|
   |                                    |

CProtocol (base)
    └── CM17Protocol (M17 protocol handler)

CClient (base)
    └── CM17Client (M17 client)

CPacketQueue (base)
    └── CCodecStream (transcoder stream to AMBEd)

Most protocol handlers use a split RX/TX thread architecture. The receive thread (RxTask) handles inbound packets, stream open/close, and timeout detection. The transmit thread (TxTask) handles outbound packet queuing, keepalives, and peer management, waking via a condition variable when packets are queued.

Split RX/TX threads: DExtra (XRF), DPlus (REF), DCS, M17, YSF, NXDN, P25 Single thread (legacy): XLX interlink, DMR+ (DMRplus), DMR MMDVM

This separation was introduced to prevent transmission tail loss — in the original single-threaded design, time spent processing outbound packets could delay reception of inbound packets, causing the final frames of a transmission to be missed or the stream to time out prematurely. With split threads, the RX path is never blocked by TX processing.

Each split protocol's stream cache uses per-slot mutexes to protect shared state between the RX and TX threads. Lock ordering is enforced across all protocols to prevent deadlocks: global locks (Peers, Clients, GateKeeper) are never held simultaneously, and peer/gatekeeper data is snapshotted into local variables before acquiring other locks.

The XLX Server acts as a YSF Master, providing 26 Wires-X rooms. It is separate from the regular YSFReflector network - registration at ysfreflector.de is optional.

XLX can connect directly to YSF reflectors as a peer, allowing bidirectional voice between YSF reflector users and XLX users (DMR, D-Star, M17, etc.).

Add YSF peers to your xlxd.interlink file:

# YSF Reflector Peering
# Format: YSF<id> <hostname>:<port> <module>
#
# - YSF ID must be 5 digits (pad with zeros if needed)
# - Port is required (typically 42000 for YSF reflectors)
# - Only ONE module allowed per YSF peer (they are single-room)

YSF12345 ysf.example.com:42000 B
YSF00999 192.168.1.100:42000 E

• XLX connects to the YSF reflector as a client using native YSF protocol
• Voice traffic flows bidirectionally between the linked module and the YSF reflector
• YSF and DMR both use AMBE2+ codec, so no transcoding is needed between them
• D-Star and M17 users are transcoded as normal

• The YSF reflector must be accessible from your XLX server
• YSF peers appear alongside XLX peers in the dashboard
• Traffic shows the originating user's callsign, not the reflector callsign

XLX can connect directly to NXDN reflectors as a peer, allowing bidirectional voice between NXDN reflector users and XLX users (DMR, D-Star, M17, YSF, etc.).

Add NXDN peers to your xlxd.interlink file:

# NXDN Reflector Peering
# Format: NXnnnnn <hostname>:<port> <module>
#
# - NXDN ID is 5 digits (00001-65535, pad with zeros if needed)
# - Port is REQUIRED (no default - NXDN reflectors use various ports)
# - Only ONE module allowed per NXDN peer (they are single-room)

NX31672 nxdn.example.com:41400 E
NX00100 192.168.1.100:41400 B

• XLX connects to the NXDN reflector as a client using native NXDN protocol
• Voice traffic flows bidirectionally between the linked module and the NXDN reflector
• No AMBEd required: NXDN uses the same AMBE2+ codec as DMR/YSF, so voice data passes directly through XLXd without transcoding
• Audio gain is automatically adjusted between NXDN↔DMR (see DMR/YSF/NXDN Audio Level Balancing section)
• D-Star and M17 users are transcoded via AMBEd as normal

XLX automatically downloads and caches the NXDN user database every 12 hours. This allows XLX to display callsigns instead of numeric NXDN IDs when users transmit.

Data Sources:

• Primary: http://database.radioid.net/static/nxdn.csv
• Fallback: http://www.pistar.uk/downloads/NXDN.csv

The user-agent is set to XLX {version} NXDN Client Updater to properly identify XLX to the upstream servers.

Configuration in main.h:

#define NXDNIDDB_USE_RLX_SERVER         1       // 1 = use http, 0 = use local file
#define NXDNIDDB_PATH                   "/xlxd/nxdn.csv"  // local file path
#define NXDNIDDB_REFRESH_RATE           720     // in minutes (12 hours)

• NXDN IDs are 16-bit (1-65535), represented as 5-digit strings
• The NXDN reflector must be accessible from your XLX server
• NXDN peers appear alongside other peers in the dashboard
• User callsigns are looked up from the NXDN ID database (falls back to "NXDNnnnnn" if not found)

XLX can connect directly to P25 reflectors as a peer, allowing bidirectional voice between P25 reflector users and XLX users (DMR, D-Star, M17, YSF, NXDN, etc.).

Note: P25 support is peer-only. XLX does not support direct P25 client connections - users must connect via a P25 reflector that is peered with XLX.

Add P25 peers to your xlxd.interlink file:

# P25 Reflector Peering
# Format: P25nnnnn <hostname>:<port> <module>
#
# - P25 ID is 5 digits (pad with zeros if needed)
# - Port is REQUIRED (no default - P25 reflectors use various ports)
# - Only ONE module allowed per P25 peer (they are single-room)

P2531672 p25.example.com:41000 E
P2500100 192.168.1.100:41000 B

• XLX connects to the P25 reflector using native P25 protocol
• Voice traffic flows bidirectionally between the linked module and the P25 reflector
• AMBEd required: Unlike NXDN which shares the AMBE2+ codec with DMR, P25 uses the IMBE codec which must be transcoded via software vocoders in AMBEd v1.4.0+
• All other modes (D-Star, DMR, YSF, NXDN, M17) are transcoded automatically

P25 uses the IMBE (Improved Multi-Band Excitation) codec. AMBEd v1.4.0+ includes software IMBE encode/decode:

• P25 peers appear alongside other peers in the dashboard
• The P25 reflector must be accessible from your XLX server
• P25 transcoding uses 2 DVSI hardware channels per stream (for AMBE encode/decode paths)
• Pure software paths (P25 ↔ M17) do not require DVSI hardware channels

XLX can connect directly to REF reflectors as a peer using the DPlus protocol, allowing bidirectional voice between REF reflector users and XLX users (DMR, M17, YSF, NXDN, P25, etc.).

Note: REF peering support is outbound only (XLX connects to REF as a client). REF reflectors cannot initiate connections to XLX.

Add REF peers to your xlxd.interlink file:

# REF/DPlus Reflector Peering
# Format: REFnnn <hostname>[:port] <local><remote>
#
# - REF callsign must be REFnnn format (e.g., REF001, REF123)
# - Port defaults to 20001 if not specified
# - Module mapping: first letter = local XLX module, second = remote REF module
# - Both module letters must be A-Z

REF001 ref001.example.com EA          # XLX module E links to REF001 module A
REF030 ref030.dstargateway.org:20001 AA    # XLX module A links to REF030 module A
REF123 192.168.1.100 BC               # XLX module B links to REF123 module C

• XLX connects to the REF reflector as a DPlus client
• Connection uses the standard DPlus handshake: connect → echo → login → ack
• Voice traffic flows bidirectionally between the linked XLX module and the remote REF module
• No AMBEd required for D-Star: REF and D-Star both use AMBE+ codec, so voice data passes directly through XLXd
• DMR, YSF, NXDN, M17, and P25 users are transcoded via AMBEd as normal

Unlike YSF/NXDN/P25 peering which only supports one module, REF peering uses explicit module mapping:

This allows you to link any XLX module to any REF module.

XLX (client)                           REF (server)
    |                                       |
    |-------- Connect (0x05) -------------->|
    |                                       |
    |<------- Connect Echo -----------------|
    |                                       |
    |-------- Login (callsign) ------------>|
    |                                       |
    |<------- Login ACK (OKRW) -------------|
    |                                       |
    |<-------- Keepalive (0x03) ----------->|
    |           (every 5 seconds)           |
    |                                       |
    |<-------- Voice Frames --------------->|
    |                                       |

• REF peers appear alongside other peers in the dashboard
• The REF reflector must be accessible from your XLX server
• D-Star traffic flows directly without transcoding
• Other modes (DMR, YSF, M17, etc.) are transcoded via AMBEd
• XLX identifies itself using its configured callsign (with REF prefix)
• Connection state is logged: connecting → logging in → connected

XLX can connect directly to XRF reflectors as a peer using the DExtra protocol, allowing bidirectional voice between XRF reflector users and XLX users (DMR, M17, YSF, NXDN, P25, etc.).

Note: XRF peering support is outbound only (XLX connects to XRF as a client). XRF reflectors cannot initiate connections to XLX via this mechanism.

Add XRF peers to your xlxd.interlink file:

# XRF/DExtra Reflector Peering
# Format: XRFnnn <hostname>[:port] <local><remote>
#
# - XRF callsign must be XRFnnn format (e.g., XRF001, XRF123)
# - Port defaults to 30001 if not specified
# - Module mapping: first letter = local XLX module, second = remote XRF module
# - Both module letters must be A-Z

XRF001 xrf001.example.com EA          # XLX module E links to XRF001 module A
XRF030 xrf030.dstargateway.org:30001 AA    # XLX module A links to XRF030 module A
XRF123 192.168.1.100 BC               # XLX module B links to XRF123 module C

• XLX connects to the XRF reflector as a DExtra client
• Connection uses the standard DExtra handshake with XRF revision 2 format
• Voice traffic flows bidirectionally between the linked XLX module and the remote XRF module
• No AMBEd required for D-Star: XRF and D-Star both use AMBE+ codec, so voice data passes directly through XLXd
• DMR, YSF, NXDN, M17, and P25 users are transcoded via AMBEd as normal

Like REF peering, XRF peering uses explicit module mapping:

This allows you to link any XLX module to any XRF module.

XLX (client)                           XRF (server)
    |                                       |
    |-------- Connect (XRF rev 2) --------->|
    |                                       |
    |<------- Connect ACK ------------------|
    |                                       |
    |<-------- Keepalive ------------------>|
    |           (every 10 seconds)          |
    |                                       |
    |<-------- Voice Frames --------------->|
    |                                       |

• XRF peers appear alongside other peers in the dashboard
• The XRF reflector must be accessible from your XLX server
• D-Star traffic flows directly without transcoding
• Other modes (DMR, YSF, M17, etc.) are transcoded via AMBEd
• XLX identifies itself using its configured callsign (with XRF prefix)

XLX can connect directly to DCS reflectors as a peer using the DCS protocol, allowing bidirectional voice between DCS reflector users and XLX users (DMR, M17, YSF, NXDN, P25, etc.).

Note: DCS peering support is outbound only (XLX connects to DCS as a client). DCS reflectors cannot initiate connections to XLX via this mechanism.

Add DCS peers to your xlxd.interlink file:

# DCS Reflector Peering
# Format: DCSnnn <hostname>[:port] <local><remote>
#
# - DCS callsign must be DCSnnn format (e.g., DCS001, DCS123)
# - Port defaults to 30051 if not specified
# - Module mapping: first letter = local XLX module, second = remote DCS module
# - Both module letters must be A-Z

DCS001 dcs001.example.com EA          # XLX module E links to DCS001 module A
DCS030 dcs030.xreflector.net:30051 AA    # XLX module A links to DCS030 module A
DCS123 192.168.1.100 BC               # XLX module B links to DCS123 module C

• XLX connects to the DCS reflector as a DCS client
• Connection uses the standard DCS handshake with 519-byte connect packet
• Voice traffic flows bidirectionally between the linked XLX module and the remote DCS module
• No AMBEd required for D-Star: DCS and D-Star both use AMBE+ codec, so voice data passes directly through XLXd
• DMR, YSF, NXDN, M17, and P25 users are transcoded via AMBEd as normal

Like REF and XRF peering, DCS peering uses explicit module mapping:

This allows you to link any XLX module to any DCS module.

XLX (client)                           DCS (server)
    |                                       |
    |-------- Connect (519 bytes) --------->|
    |                                       |
    |<------- Connect ACK (14 bytes) -------|
    |                                       |
    |<-------- Keepalive ------------------>|
    |           (every 5 seconds)           |
    |                                       |
    |<-------- Voice Frames --------------->|
    |                                       |

• DCS peers appear alongside other peers in the dashboard
• The DCS reflector must be accessible from your XLX server
• D-Star traffic flows directly without transcoding
• Other modes (DMR, YSF, M17, etc.) are transcoded via AMBEd
• XLX identifies itself using its configured callsign

• Verify UDP port 17000 is open in firewall
• Check reflector logs for connection attempts
• Ensure client is using correct callsign format

• M17 uses software Codec2 transcoding (full fidelity)
• AMBE encode/decode uses DVSI hardware via AMBEd
• If audio is poor, check ambed connectivity and DVSI hardware

• Verify AMBEd v1.4.0+ is running and connected
• Check console output for codec stream creation messages
• Ensure Codec2 library initialized correctly in ambed

• Verify the P25 reflector hostname and port are correct in xlxd.interlink
• Check that outbound UDP to the P25 reflector port is not blocked
• AMBEd v1.4.0+ is required for IMBE software vocoder support
• Check ambed startup output for "Software vocoders : X IMBE (P25), X Codec2 (M17)"

• Verify the REF hostname and port are correct in xlxd.interlink (default port 20001)
• Check that outbound UDP to the REF port is not blocked by firewall
• Module string must be exactly 2 uppercase letters (e.g., "AA", "EA", "BC")
• Check logs for connection state: "DPlus connecting" → "connect echo" → "login ack - connected"
• If stuck at "connecting", the REF may be unreachable or port blocked
• If stuck at "logging in", the REF may be rejecting the login (check REF's whitelist)
• If "login nack" received, your callsign may not be authorized on that REF

• Verify the XRF hostname and port are correct in xlxd.interlink (default port 30001)
• Check that outbound UDP to the XRF port is not blocked by firewall
• Module string must be exactly 2 uppercase letters (e.g., "AA", "EA", "BC")
• Check logs for "DExtra connecting" → "connect ack - connected"
• If stuck at "connecting", the XRF may be unreachable or port blocked
• If connect timeout occurs, the XRF may not be accepting connections

• Verify the DCS hostname and port are correct in xlxd.interlink (default port 30051)
• Check that outbound UDP to the DCS port is not blocked by firewall
• Module string must be exactly 2 uppercase letters (e.g., "AA", "EA", "BC")
• Check logs for "DCS peer connecting" → "DCS peer connected"
• If stuck at "connecting", the DCS reflector may be unreachable or port blocked
• If connect timeout occurs, the DCS may not be accepting connections
• DCS uses 519-byte connect packets - ensure no packet fragmentation issues

GPL v3 - See LICENSE file for details.

• Jean-Luc Deltombe (LX3JL) - XLX original author
• Luc Engelmann (LX1IQ) - XLX contributor

• Andy Taylor (MW0MWZ) - M17 native support implementation for XLX
  • Native M17 reflector connectivity
  • Codec2 software transcoding integrated with AMBEd
• M17 Project - M17 protocol specification (https://m17project.org)

• Andy Taylor (MW0MWZ) - YSF reflector peering implementation
  • Native YSF protocol peering support
  • Bidirectional voice bridging between YSF reflectors and XLX
• Jonathan Naylor (G4KLX) - MMDVMHost (https://github.com/g4klx/MMDVMHost)
  • YSF protocol reference implementation

• Andy Taylor (MW0MWZ) - NXDN reflector peering implementation
  • Native NXDN protocol peering support
  • Bidirectional voice bridging between NXDN reflectors and XLX
• Jonathan Naylor (G4KLX) - MMDVMHost (https://github.com/g4klx/MMDVMHost)
  • NXDN protocol reference implementation
• Andy Uribe (CA6JAU) - NXDN cross-mode gateway implementations
  • NXDN2DMR (https://github.com/juribeparada/NXDN2DMR)
  • DMR2NXDN (https://github.com/juribeparada/DMR2NXDN)
• Doug McLain (AD8DP) - Current maintainer of NXDN cross-mode gateways
  • Protocol handling and cross-mode patterns

• Andy Taylor (MW0MWZ) - P25 reflector peering implementation
  • Native P25 protocol peering support
  • Bidirectional voice bridging between P25 reflectors and XLX
• Jonathan Naylor (G4KLX) - MMDVMHost (https://github.com/g4klx/MMDVMHost)
  • P25 protocol reference implementation
• Doug McLain (AD8DP) - P25 cross-mode gateway implementations
  • DMR2P25 and P252DMR (https://github.com/nostar)
  • Cross-mode patterns and protocol handling inspiration

• Andy Taylor (MW0MWZ) - REF/DPlus reflector peering implementation
  • Native DPlus protocol peering support (XLX as client to REF)
  • Bidirectional voice bridging between REF reflectors and XLX
  • Module mapping support (any XLX module to any REF module)
• Jonathan Naylor (G4KLX) - ircDDBGateway (https://github.com/g4klx/ircDDBGateway)
  • DPlus protocol reference implementation

• Andy Taylor (MW0MWZ) - XRF/DExtra reflector peering implementation
  • Native DExtra protocol peering support (XLX as client to XRF)
  • Bidirectional voice bridging between XRF reflectors and XLX
  • Module mapping support (any XLX module to any XRF module)
• Jonathan Naylor (G4KLX) - ircDDBGateway (https://github.com/g4klx/ircDDBGateway)
  • DExtra protocol reference implementation

• Andy Taylor (MW0MWZ) - DCS reflector peering implementation
  • Native DCS protocol peering support (XLX as client to DCS)
  • Bidirectional voice bridging between DCS reflectors and XLX
  • Module mapping support (any XLX module to any DCS module)
• Jonathan Naylor (G4KLX) - ircDDBGateway (https://github.com/g4klx/ircDDBGateway)
  • DCS protocol reference implementation

• David Rowe (VK5DGR) - Codec2 library author (https://github.com/drowe67/codec2)
• Open source voice codec used by M17 protocol
• 3200bps mode provides 8 bytes per 20ms voice frame

• OP25 Project by Osmocom - Software IMBE vocoder (https://github.com/osmocom/op25)
• 88-bit frames (11 bytes) per 20ms voice frame
• Used for P25 reflector peering support

(c) 2016 Jean-Luc Deltombe (LX3JL) and Luc Engelmann (LX1IQ)