use libmpegts::ts::TsPacketRef;
use super::*;
fn ecm_section(cp_number: u16) -> Vec<u8> {
let [hi, lo] = cp_number.to_be_bytes();
vec![0x80 | (cp_number & 1) as u8, 0x70, 0x02, hi, lo]
}
fn ecm_ts_packet(cp_number: u16) -> Vec<u8> {
let mut packet = vec![0xFF; 188];
packet[.. 4].copy_from_slice(&[0x47, 0x5F, 0xFF, 0x10]);
packet[4 .. 6].copy_from_slice(&cp_number.to_be_bytes());
packet
}
async fn open(
simulcrypt: &Simulcrypt,
section_ts_pkt_flag: u8,
rep_period: Option<u16>,
ecm: fn(u16) -> Vec<u8>,
ecm_pids: &[u16],
) -> (CasLease, simulcrypt::Service) {
let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
let port = listener.local_addr().unwrap().port();
tokio::spawn(ecmg_peer(listener, 1, section_ts_pkt_flag, rep_period, ecm));
let lease = simulcrypt
.acquire_cas(CasConfig {
id: format!("cas-carousel-{port}"),
name: "carousel".into(),
super_cas_id: 0x0900_0001,
first_stream_id: 1,
ecmg: EcmgConfig::new(1, SocketAddr::from(([127, 0, 0, 1], port))),
emmg: None,
})
.expect("acquire_cas");
let service = simulcrypt
.open_service(&ServiceConfig {
name: "svc-carousel".into(),
crypto_period: Duration::from_millis(300),
cas: ecm_pids
.iter()
.map(|&ecm_pid| ServiceCas {
cas: lease.cas(),
ecm_pid,
access_criteria: vec![],
})
.collect(),
})
.expect("open_service");
(lease, service)
}
async fn next_ts(service: &mut simulcrypt::Service) -> Vec<[u8; 188]> {
loop {
if let Event::Ts(packets) = service.recv().await.expect("service closed unexpectedly") {
return packets;
}
}
}
#[tokio::test]
async fn carousel_repeats_the_current_ecm_at_rep_period() {
let simulcrypt = Simulcrypt::new();
let (_lease, mut service) = open(&simulcrypt, 0x00, Some(40), ecm_section, &[0x0100]).await;
let first = tokio::time::timeout(Duration::from_secs(5), next_ts(&mut service))
.await
.expect("first carousel packet");
let started = tokio::time::Instant::now();
let mut packets = vec![first[0]];
while packets.len() < 25 {
let ts = tokio::time::timeout(Duration::from_secs(5), next_ts(&mut service))
.await
.expect("carousel packet");
assert_eq!(ts.len(), 1);
packets.push(ts[0]);
}
let elapsed = started.elapsed();
assert!(
elapsed >= Duration::from_millis(23 * 40) && elapsed < Duration::from_millis(1700),
"24 repetitions took {elapsed:?}"
);
let first_cc = TsPacketRef::from(&packets[0]).cc();
let mut cp_numbers = Vec::new();
for (index, packet) in packets.iter().enumerate() {
let packet = TsPacketRef::from(packet);
assert_eq!(packet.pid(), 0x0100);
assert_eq!(
packet.cc(),
(first_cc + index as u8) & 0x0F,
"continuity counter"
);
assert!(packet.is_payload_start());
let payload = packet.payload().unwrap();
assert_eq!(payload[0], 0, "pointer field");
let cp_number = u16::from_be_bytes([payload[4], payload[5]]);
assert_eq!(&payload[1 .. 6], ecm_section(cp_number));
assert!(payload[6 ..].iter().all(|&byte| byte == 0xFF));
if !cp_numbers.contains(&cp_number) {
cp_numbers.push(cp_number);
}
}
assert!(
cp_numbers.len() >= 2,
"the ECM of a new crypto period must replace the old one: {cp_numbers:?}"
);
}
#[tokio::test]
async fn carousel_restamps_ts_packets_and_skips_reserved_pids() {
let simulcrypt = Simulcrypt::new();
let (_lease, mut service) =
open(&simulcrypt, 0x01, None, ecm_ts_packet, &[0x0200, 0x0000]).await;
let reserved = service
.streams()
.iter()
.find(|info| info.ecm_pid == 0)
.unwrap()
.stream_id;
let mut ts = 0;
let mut raw_on_reserved = false;
tokio::time::timeout(Duration::from_secs(5), async {
while ts < 5 || !raw_on_reserved {
match service.recv().await.expect("service closed unexpectedly") {
Event::Ts(packets) => {
for packet in &packets {
let packet = TsPacketRef::from(packet);
assert_eq!(packet.pid(), 0x0200);
assert!(packet.is_payload_start());
assert_eq!(packet.payload().unwrap()[2 ..], [0xFF; 182]);
}
ts += 1;
}
Event::Ecm { stream_id, .. } if stream_id == reserved => raw_on_reserved = true,
_ => {}
}
}
})
.await
.expect("carousel packets and the raw ECM of the reserved PID");
}