1 use std::fmt; 2 use std::sync::{Arc, Mutex}; 3 4 /// Sequencer generates sequential sequence numbers for building RTP packets 5 pub trait Sequencer: fmt::Debug { 6 fn next_sequence_number(&self) -> u16; 7 fn roll_over_count(&self) -> u64; 8 fn clone_to(&self) -> Box<dyn Sequencer + Send + Sync>; 9 } 10 11 impl Clone for Box<dyn Sequencer + Send + Sync> { 12 fn clone(&self) -> Box<dyn Sequencer + Send + Sync> { 13 self.clone_to() 14 } 15 } 16 17 /// NewRandomSequencer returns a new sequencer starting from a random sequence 18 /// number 19 pub fn new_random_sequencer() -> impl Sequencer { 20 let c = Counters { 21 sequence_number: rand::random::<u16>(), 22 roll_over_count: 0, 23 }; 24 SequencerImpl(Arc::new(Mutex::new(c))) 25 } 26 27 /// NewFixedSequencer returns a new sequencer starting from a specific 28 /// sequence number 29 pub fn new_fixed_sequencer(s: u16) -> impl Sequencer { 30 let sequence_number = if s == 0 { u16::MAX } else { s - 1 }; 31 32 let c = Counters { 33 sequence_number, 34 roll_over_count: 0, 35 }; 36 37 SequencerImpl(Arc::new(Mutex::new(c))) 38 } 39 40 #[derive(Debug, Clone)] 41 struct SequencerImpl(Arc<Mutex<Counters>>); 42 43 #[derive(Debug)] 44 struct Counters { 45 sequence_number: u16, 46 roll_over_count: u64, 47 } 48 49 impl Sequencer for SequencerImpl { 50 /// NextSequenceNumber increment and returns a new sequence number for 51 /// building RTP packets 52 fn next_sequence_number(&self) -> u16 { 53 let mut lock = self.0.lock().unwrap(); 54 55 if lock.sequence_number == u16::MAX { 56 lock.roll_over_count += 1; 57 lock.sequence_number = 0; 58 } else { 59 lock.sequence_number += 1; 60 } 61 62 lock.sequence_number 63 } 64 65 /// RollOverCount returns the amount of times the 16bit sequence number 66 /// has wrapped 67 fn roll_over_count(&self) -> u64 { 68 self.0.lock().unwrap().roll_over_count 69 } 70 71 fn clone_to(&self) -> Box<dyn Sequencer + Send + Sync> { 72 Box::new(self.clone()) 73 } 74 } 75