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