sndplay/src/demux.rs

   1 use std::io::SeekFrom;
   2 use nihav_core::codecs::*;
   3 use nihav_core::demuxers::*;
   4 use nihav_registry::detect;
   5 use nihav_core::io::byteio::ByteReader;
   6 use super::allreg::FullRegister;
   7
   8 pub struct RawStreamCtx<'a> {
   9     stream: NAStreamRef,
  10     pkt:    Box<dyn NAPacketiser + Send>,
  11     br:     &'a mut ByteReader<'a>,
  12     pts:    u64,
  13     seek:   SeekIndex,
  14 }
  15
  16 impl<'a> RawStreamCtx<'a> {
  17     fn new(stream: NAStreamRef, packetiser: Box<dyn NAPacketiser + Send>, br: &'a mut ByteReader<'a>) -> Self {
  18         let mut seek = SeekIndex::new();
  19         seek.add_stream(0);
  20         Self { stream, pkt: packetiser, br, pts: 0, seek }
  21     }
  22     fn account_for_packet(&mut self, packet: &mut NAPacket) {
  23         let pos = self.br.tell() - (self.pkt.bytes_left() as u64);
  24         if packet.get_pts().is_none() && packet.get_duration().is_some() {
  25             packet.ts.pts = Some(self.pts);
  26         }
  27         if packet.is_keyframe() {
  28             let pts = packet.get_pts().unwrap_or(self.pts);
  29             let time = NATimeInfo::ts_to_time(pts, 1000, self.stream.tb_num, self.stream.tb_den);
  30             let in_range = if let Some(last) = self.seek.seek_info[0].entries.last() {
  31                     last.pts >= pts
  32                 } else {
  33                     false
  34                 };
  35             if !in_range {
  36                 self.seek.add_entry(0, SeekEntry { time, pts, pos });
  37             }
  38         }
  39         self.pts += packet.get_duration().unwrap_or(0);
  40     }
  41     fn get_frame(&mut self) -> DemuxerResult<NAPacket> {
  42         let mut buf = [0; 1048576];
  43         loop {
  44             match self.pkt.get_packet(self.stream.clone()) {
  45                 Ok(Some(mut packet)) => {
  46                     self.account_for_packet(&mut packet);
  47                     return Ok(packet);
  48                 },
  49                 Ok(None) => {},
  50                 Err(DecoderError::ShortData) => {},
  51                 _ => return Err(DemuxerError::InvalidData),
  52             };
  53             match self.br.read_buf_some(&mut buf) {
  54                 Ok(size) => {
  55                     self.pkt.add_data(&buf[..size]);
  56                 },
  57                 Err(_) => {
  58                     match self.pkt.get_packet(self.stream.clone()) {
  59                         Ok(Some(mut packet)) => {
  60                             self.account_for_packet(&mut packet);
  61                             return Ok(packet);
  62                         },
  63                         Ok(None) | Err(DecoderError::ShortData) => return Err(DemuxerError::EOF),
  64                         _ => return Err(DemuxerError::InvalidData),
  65                     };
  66                 },
  67             };
  68         }
  69     }
  70 }
  71
  72 pub enum DemuxerObject<'a> {
  73     None,
  74     Normal(Demuxer<'a>),
  75     Raw(RawDemuxer<'a>, Vec<Option<Box<dyn NAPacketiser + Send>>>, bool),
  76     RawStream(RawStreamCtx<'a>),
  77 }
  78
  79 impl<'a> DemuxerObject<'a> {
  80     pub fn create(br: &'a mut ByteReader<'a>, reg: &FullRegister, name: &str, is_raw: bool) -> DemuxerObject<'a> {
  81         if !is_raw {
  82             let res = detect::detect_format(name, br);
  83             let (dmx_name, _) = res.unwrap_or(("", detect::DetectionScore::No));
  84             if !dmx_name.is_empty() {
  85                 println!("trying demuxer {} on {}", dmx_name, name);
  86                 if let Some(dmx_fact) = reg.dmx_reg.find_demuxer(dmx_name) {
  87                     br.seek(SeekFrom::Start(0)).unwrap();
  88                     let dmx = create_demuxer(dmx_fact, br).unwrap();
  89                     return DemuxerObject::Normal(dmx);
  90                 }
  91             }
  92             if !dmx_name.is_empty() {
  93                 println!("trying raw demuxer {} on {}", dmx_name, name);
  94                 if let Some(rdmx_fact) = reg.rdmx_reg.find_demuxer(dmx_name) {
  95                     br.seek(SeekFrom::Start(0)).unwrap();
  96                     let dmx = create_raw_demuxer(rdmx_fact, br).unwrap();
  97                     let mut pkts = Vec::new();
  98                     for stream in dmx.get_streams() {
  99                         if let Some(pcreate) = reg.pkt_reg.find_packetiser(stream.get_info().get_name()) {
 100                             let packetiser = (pcreate)();
 101                             pkts.push(Some(packetiser));
 102                         } else {
 103                             pkts.push(None);
 104                         }
 105                     }
 106                     return DemuxerObject::Raw(dmx, pkts, false);
 107                 }
 108             }
 109             for rdmx in reg.rdmx_reg.iter() {
 110                 if rdmx.check_format(br) {
 111                     println!("detected {} as {}", name, rdmx.get_name());
 112                     br.seek(SeekFrom::Start(0)).unwrap();
 113                     let dmx = create_raw_demuxer(*rdmx, br).unwrap();
 114                     let mut pkts = Vec::new();
 115                     for stream in dmx.get_streams() {
 116                         if let Some(pcreate) = reg.pkt_reg.find_packetiser(stream.get_info().get_name()) {
 117                             let packetiser = (pcreate)();
 118                             pkts.push(Some(packetiser));
 119                         } else {
 120                             pkts.push(None);
 121                         }
 122                     }
 123                     return DemuxerObject::Raw(dmx, pkts, false);
 124                 }
 125             }
 126         }
 127         br.seek(SeekFrom::Start(0)).unwrap();
 128         let mut buf = vec![0; 1048576];
 129         let size = br.read_buf_some(&mut buf).unwrap();
 130         br.seek(SeekFrom::Start(0)).unwrap();
 131         let mut pname = "";
 132
 133         for pinfo in reg.pkt_reg.iter() {
 134             let mut packetiser = (pinfo.get_packetiser)();
 135             packetiser.add_data(&buf[..size]);
 136             if packetiser.parse_stream(0).is_ok() {
 137                 pname = pinfo.name;
 138                 break;
 139             }
 140         }
 141         if !pname.is_empty() {
 142             println!("found raw stream of type {} for {}", pname, name);
 143             let pcreate = reg.pkt_reg.find_packetiser(pname).unwrap();
 144             let mut packetiser = (pcreate)();
 145             packetiser.add_data(&buf[..size]);
 146             let stream = packetiser.parse_stream(0).unwrap();
 147             packetiser.reset();
 148             DemuxerObject::RawStream(RawStreamCtx::new(stream, packetiser, br))
 149         } else {
 150             DemuxerObject::None
 151         }
 152     }
 153     pub fn is_none(&self) -> bool {
 154         matches!(*self, DemuxerObject::None)
 155     }
 156     pub fn get_duration(&self) -> u64 {
 157         match *self {
 158             DemuxerObject::Normal(ref dmx) => dmx.get_duration(),
 159             DemuxerObject::Raw(ref dmx, _, _) => dmx.get_duration(),
 160             DemuxerObject::RawStream(ref ctx) => {
 161                 NATimeInfo::ts_to_time(ctx.stream.duration, 1000, ctx.stream.tb_num, ctx.stream.tb_den)
 162             },
 163             _ => 0,
 164         }
 165     }
 166     pub fn get_num_streams(&self) -> usize {
 167         match *self {
 168             DemuxerObject::None => 0,
 169             DemuxerObject::Normal(ref dmx) => dmx.get_num_streams(),
 170             DemuxerObject::Raw(ref dmx, _, _) => dmx.get_num_streams(),
 171             DemuxerObject::RawStream(_) => 1,
 172         }
 173     }
 174     pub fn get_stream(&self, idx: usize) -> Option<NAStreamRef> {
 175         match *self {
 176             DemuxerObject::Normal(ref dmx) => dmx.get_stream(idx),
 177             DemuxerObject::Raw(ref dmx, _, _) => dmx.get_stream(idx),
 178             DemuxerObject::RawStream(ref ctx) if idx == 0 => Some(ctx.stream.clone()),
 179             _ => None,
 180         }
 181     }
 182     pub fn get_frame(&mut self) -> DemuxerResult<NAPacket> {
 183         match *self {
 184             DemuxerObject::Normal(ref mut dmx) => dmx.get_frame(),
 185             DemuxerObject::Raw(ref mut dmx, ref mut packetisers, ref mut eof) => {
 186                 loop {
 187                     let mut has_some = false;
 188                     for (stream, p) in dmx.get_streams().zip(packetisers.iter_mut()) {
 189                         if let Some(ref mut pkts) = p {
 190                             match pkts.get_packet(stream.clone()) {
 191                                 Ok(Some(pkt)) => return Ok(pkt),
 192                                 Ok(None) | Err(DecoderError::ShortData) => {
 193                                     if *eof {
 194                                         *p = None;
 195                                     }
 196                                 },
 197                                 Err(err) => {
 198                                     println!("packetisation error {:?}", err);
 199                                     return Err(DemuxerError::InvalidData);
 200                                 }
 201                             };
 202                             has_some |= p.is_some();
 203                         }
 204                     }
 205                     if !has_some {
 206                         return Err(DemuxerError::EOF);
 207                     }
 208                     if let Ok(data) = dmx.get_data() {
 209                         let id = data.get_stream().get_id();
 210                         for (i, stream) in dmx.get_streams().enumerate() {
 211                             if stream.get_id() == id {
 212                                 if let Some(ref mut pkts) = packetisers[i] {
 213                                     pkts.add_data(&data.get_buffer());
 214                                 }
 215                                 break;
 216                             }
 217                         }
 218                     } else {
 219                         *eof = true;
 220                     }
 221                 }
 222             },
 223             DemuxerObject::RawStream(ref mut ctx) => ctx.get_frame(),
 224             _ => unreachable!(),
 225         }
 226     }
 227     pub fn seek(&mut self, seek_time: NATimePoint) -> DemuxerResult<()> {
 228         match *self {
 229             DemuxerObject::Normal(ref mut dmx) => dmx.seek(seek_time),
 230             DemuxerObject::Raw(ref mut dmx, _, _) => dmx.seek(seek_time),
 231             DemuxerObject::RawStream(ref mut ctx) => {
 232                 if seek_time == NATimePoint::None {
 233                     return Err(DemuxerError::SeekError);
 234                 }
 235                 if let Some(last) = ctx.seek.seek_info[0].entries.last() {
 236                     let in_index = match seek_time {
 237                             NATimePoint::None => unreachable!(),
 238                             NATimePoint::PTS(pts) => last.pts >= pts,
 239                             NATimePoint::Milliseconds(ms) => last.time >= ms,
 240                         };
 241                     if in_index {
 242                         if let Some(result) = ctx.seek.find_pos(seek_time) {
 243                             ctx.br.seek(SeekFrom::Start(result.pos))?;
 244                             ctx.pts = result.pts;
 245                             ctx.pkt.reset();
 246                             return Ok(());
 247                         }
 248                     }
 249                 }
 250                 if let Some(last) = ctx.seek.seek_info[0].entries.last() {
 251                     ctx.br.seek(SeekFrom::Start(last.pos))?;
 252                     ctx.pts = last.pts;
 253                     ctx.pkt.reset();
 254                 }
 255                 let mut key_pts = 0;
 256                 while let Ok(pkt) = ctx.get_frame() {
 257                     if !pkt.ts.less_than(seek_time) && !pkt.ts.equal(seek_time) {
 258                         break;
 259                     }
 260                     if pkt.is_keyframe() {
 261                         key_pts = pkt.get_pts().unwrap_or(0);
 262                     }
 263                 }
 264                 let result = ctx.seek.find_pos(NATimePoint::PTS(key_pts)).unwrap();
 265                 ctx.br.seek(SeekFrom::Start(result.pos))?;
 266                 ctx.pts = result.pts;
 267                 ctx.pkt.reset();
 268                 Ok(())
 269             },
 270             _ => Err(DemuxerError::NotImplemented),
 271         }
 272     }
 273 }
 274
 275 pub fn detect_tags(br: &mut ByteReader) -> (bool, u64, Option<u64>) {
 276     let mut is_raw = false;
 277     let mut start = 0;
 278     let mut end = None;
 279
 280     // check for ID3v{2-4}
 281     let mut buf = [0; 5];
 282     loop {
 283         if br.peek_buf(&mut buf).is_err() {
 284             break;
 285         }
 286         if &buf[0..3] == b"ID3" && buf[3] > 0 && buf[3] < 5 && buf[4] == 0 { //ID3 tag found, must be a raw stream
 287             br.read_skip(6).unwrap();
 288             let mut size = 0;
 289             for _ in 0..4 {
 290                 let b = br.read_byte().unwrap();
 291                 if (b & 0x80) != 0 {
 292                     println!("Invalid ID3 size");
 293                     break;
 294                 }
 295                 size = (size << 7) | u64::from(b);
 296             }
 297             start += size + 10;
 298             br.read_skip(size as usize).unwrap();
 299             while let Ok(0) = br.read_byte() {
 300                 start += 1;
 301             }
 302             br.seek(SeekFrom::Start(start)).unwrap();
 303             is_raw = true;
 304         } else {
 305             break;
 306         }
 307     }
 308     // check for ID3v1
 309     br.seek(SeekFrom::End(-128)).unwrap();
 310     let off = br.tell();
 311     br.peek_buf(&mut buf[..3]).unwrap();
 312     if &buf[0..3] == b"TAG" {
 313         end = Some(off);
 314         // check for Lyrics v2
 315         let mut sig = [0; 9];
 316         br.seek(SeekFrom::End(-128 - 9)).unwrap();
 317         br.peek_buf(&mut sig).unwrap();
 318         if &sig == b"LYRICS200" {
 319             br.seek(SeekFrom::Current(-6)).unwrap();
 320             let mut sizestr = [0; 6];
 321             br.peek_buf(&mut sizestr).unwrap();
 322             if let Ok(sstr) = std::str::from_utf8(&sizestr) {
 323                 if let Ok(size) = sstr.parse::<u64>() {
 324                     end = Some(br.tell() - size);
 325                 }
 326             }
 327         }
 328     }
 329     // check for APETAG
 330     let mut buf = [0; 8];
 331     if let Some(off) = end {
 332         br.seek(SeekFrom::Start(off - 32)).unwrap();
 333     } else {
 334         br.seek(SeekFrom::End(-32)).unwrap();
 335     }
 336     let off = br.tell();
 337     br.read_buf(&mut buf).unwrap();
 338     if &buf == b"APETAGEX" {
 339         let ver     = br.read_u32le().unwrap();
 340         let size    = u64::from(br.read_u32le().unwrap());
 341         let _items  = br.read_u32le().unwrap();
 342         let flags   = br.read_u32le().unwrap();
 343         if ver == 1000 || (flags & 0x80000000) == 0 {
 344             end = Some(off - size + 32);
 345         } else {
 346             end = Some(off - size);
 347         }
 348     }
 349
 350     (is_raw, start, end)
 351 }