jittr

jittr

Une implémentation de tampon de gigue basée sur un tas binaire pour les flux udp/rtp à latence nulle

Cette implémentation est conçue pour lutter contre la gigue du réseau et créer des flux multimédias fiables via des paquets UDP. Les paquets non ordonnés et les délais variables du réseau sont l'un des plus gros problèmes lorsque l'on essaie de diffuser constamment, par exemple, de l'audio via UDP (et très probablement RTP). Cette structure de données met les paquets en mémoire tampon et les réorganise tout en introduisant le moins de retard possible.

Exemples

Opus

Lecture des paquets d'opus à partir d'un flux udp/rtp via le tampon de gigue :

 use async_std :: stream :: interval ;
use std :: time :: Duration ;
use jittr :: { JitterBuffer , Packet } ;

let mut rtp_stream = /* your rtp stream */ ;

/// Your Packet implementation
struct Opus { .. }
impl Packet for Opus { .. }

/// Create a jitter buffer for Opus packets
/// It can hold up to 10 packets before it starts to discard old packets
let mut jitter = JitterBuffer :: < Opus , 10 > :: new ( ) ;

/// Create an interval for packet playback
/// A typical length for audio packets is between 10 and 20ms
let mut playback = interval ( Duration :: from_millis ( 20 ) ) ;

loop {
    futures :: select! {
        _ = playback . next ( ) . fuse ( ) => {
            let packet = jittr . pop ( ) ;

            let pcm = /* Opus decodes audio if present or infers if none */

            // Write pcm to speaker
        } ,
        rtp = rtp_stream . next ( ) . fuse ( ) => {
            let opus : Opus = rtp . unwrap ( ) ;
            jittr . push ( opus ) ;
        } ,
    }
} 

Ce code a été initialement publié par HUM Systems. Ce référentiel poursuit le développement de cette bibliothèque alors qu'ils ont malheureusement arrêté leurs efforts open source.