1 use std::sync::{Arc, Mutex}; 2 3 // Sequencer generates sequential sequence numbers for building RTP packets 4 pub trait Sequencer { 5 fn next_sequence_number(&mut self) -> u16; 6 fn roll_over_count(&self) -> u64; 7 } 8 9 // NewRandomSequencer returns a new sequencer starting from a random sequence 10 // number 11 pub fn new_random_sequencer() -> impl Sequencer { 12 SequencerImpl { 13 mutex: Arc::new(Mutex::new(SequencerInternal { 14 sequence_number: rand::random::<u16>(), 15 roll_over_count: 0, 16 })), 17 } 18 } 19 20 // NewFixedSequencer returns a new sequencer starting from a specific 21 // sequence number 22 pub fn new_fixed_sequencer(s: u16) -> impl Sequencer { 23 SequencerImpl { 24 mutex: Arc::new(Mutex::new(SequencerInternal { 25 sequence_number: s - 1, 26 roll_over_count: 0, 27 })), 28 } 29 } 30 31 struct SequencerInternal { 32 sequence_number: u16, 33 roll_over_count: u64, 34 } 35 36 struct SequencerImpl { 37 mutex: Arc<Mutex<SequencerInternal>>, 38 } 39 40 // NextSequenceNumber increment and returns a new sequence number for 41 // building RTP packets 42 impl Sequencer for SequencerImpl { 43 fn next_sequence_number(&mut self) -> u16 { 44 let mut s = self.mutex.lock().unwrap(); 45 s.sequence_number += 1; 46 if s.sequence_number == 0 { 47 s.roll_over_count += 1; 48 } 49 return s.sequence_number; 50 } 51 52 // RollOverCount returns the amount of times the 16bit sequence number 53 // has wrapped 54 fn roll_over_count(&self) -> u64 { 55 let s = self.mutex.lock().unwrap(); 56 return s.roll_over_count; 57 } 58 } 59