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 != "" {
  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 != "" {
  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 != "" {
 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         match *self {
 155             DemuxerObject::None => true,
 156             _ => false,
 157         }
 158     }
 159     pub fn get_duration(&self) -> u64 {
 160         match *self {
 161             DemuxerObject::Normal(ref dmx) => dmx.get_duration(),
 162             DemuxerObject::Raw(ref dmx, _, _) => dmx.get_duration(),
 163             DemuxerObject::RawStream(ref ctx) => {
 164                 NATimeInfo::ts_to_time(ctx.stream.duration, 1000, ctx.stream.tb_num, ctx.stream.tb_den)
 165             },
 166             _ => 0,
 167         }
 168     }
 169     pub fn get_num_streams(&self) -> usize {
 170         match *self {
 171             DemuxerObject::None => 0,
 172             DemuxerObject::Normal(ref dmx) => dmx.get_num_streams(),
 173             DemuxerObject::Raw(ref dmx, _, _) => dmx.get_num_streams(),
 174             DemuxerObject::RawStream(_) => 1,
 175         }
 176     }
 177     pub fn get_stream(&self, idx: usize) -> Option<NAStreamRef> {
 178         match *self {
 179             DemuxerObject::Normal(ref dmx) => dmx.get_stream(idx),
 180             DemuxerObject::Raw(ref dmx, _, _) => dmx.get_stream(idx),
 181             DemuxerObject::RawStream(ref ctx) if idx == 0 => Some(ctx.stream.clone()),
 182             _ => None,
 183         }
 184     }
 185     pub fn get_frame(&mut self) -> DemuxerResult<NAPacket> {
 186         match *self {
 187             DemuxerObject::Normal(ref mut dmx) => dmx.get_frame(),
 188             DemuxerObject::Raw(ref mut dmx, ref mut packetisers, ref mut eof) => {
 189                 loop {
 190                     let mut has_some = false;
 191                     for (stream, p) in dmx.get_streams().zip(packetisers.iter_mut()) {
 192                         if let Some(ref mut pkts) = p {
 193                             match pkts.get_packet(stream.clone()) {
 194                                 Ok(Some(pkt)) => return Ok(pkt),
 195                                 Ok(None) | Err(DecoderError::ShortData) => {
 196                                     if *eof {
 197                                         *p = None;
 198                                     }
 199                                 },
 200                                 Err(err) => {
 201                                     println!("packetisation error {:?}", err);
 202                                     return Err(DemuxerError::InvalidData);
 203                                 }
 204                             };
 205                             has_some |= p.is_some();
 206                         }
 207                     }
 208                     if !has_some {
 209                         return Err(DemuxerError::EOF);
 210                     }
 211                     if let Ok(data) = dmx.get_data() {
 212                         let id = data.get_stream().get_id();
 213                         for (i, stream) in dmx.get_streams().enumerate() {
 214                             if stream.get_id() == id {
 215                                 if let Some(ref mut pkts) = packetisers[i] {
 216                                     pkts.add_data(&data.get_buffer());
 217                                 }
 218                                 break;
 219                             }
 220                         }
 221                     } else {
 222                         *eof = true;
 223                     }
 224                 }
 225             },
 226             DemuxerObject::RawStream(ref mut ctx) => ctx.get_frame(),
 227             _ => unreachable!(),
 228         }
 229     }
 230     pub fn seek(&mut self, seek_time: NATimePoint) -> DemuxerResult<()> {
 231         match *self {
 232             DemuxerObject::Normal(ref mut dmx) => dmx.seek(seek_time),
 233             DemuxerObject::Raw(ref mut dmx, _, _) => dmx.seek(seek_time),
 234             DemuxerObject::RawStream(ref mut ctx) => {
 235                 if seek_time == NATimePoint::None {
 236                     return Err(DemuxerError::SeekError);
 237                 }
 238                 if let Some(last) = ctx.seek.seek_info[0].entries.last() {
 239                     let in_index = match seek_time {
 240                             NATimePoint::None => unreachable!(),
 241                             NATimePoint::PTS(pts) => last.pts >= pts,
 242                             NATimePoint::Milliseconds(ms) => last.time >= ms,
 243                         };
 244                     if in_index {
 245                         if let Some(result) = ctx.seek.find_pos(seek_time) {
 246                             ctx.br.seek(SeekFrom::Start(result.pos))?;
 247                             ctx.pts = result.pts;
 248                             ctx.pkt.reset();
 249                             return Ok(());
 250                         }
 251                     }
 252                 }
 253                 if let Some(last) = ctx.seek.seek_info[0].entries.last() {
 254                     ctx.br.seek(SeekFrom::Start(last.pos))?;
 255                     ctx.pts = last.pts;
 256                     ctx.pkt.reset();
 257                 }
 258                 let mut key_pts = 0;
 259                 while let Ok(pkt) = ctx.get_frame() {
 260                     if !pkt.ts.less_than(seek_time) && !pkt.ts.equal(seek_time) {
 261                         break;
 262                     }
 263                     if pkt.is_keyframe() {
 264                         key_pts = pkt.get_pts().unwrap_or(0);
 265                     }
 266                 }
 267                 let result = ctx.seek.find_pos(NATimePoint::PTS(key_pts)).unwrap();
 268                 ctx.br.seek(SeekFrom::Start(result.pos))?;
 269                 ctx.pts = result.pts;
 270                 ctx.pkt.reset();
 271                 Ok(())
 272             },
 273             _ => Err(DemuxerError::NotImplemented),
 274         }
 275     }
 276 }
 277
 278 pub fn detect_tags(br: &mut ByteReader) -> (bool, u64, Option<u64>) {
 279     let mut is_raw = false;
 280     let mut start = 0;
 281     let mut end = None;
 282
 283     // check for ID3v{2-4}
 284     let mut buf = [0; 5];
 285     loop {
 286         if br.peek_buf(&mut buf).is_err() {
 287             break;
 288         }
 289         if &buf[0..3] == b"ID3" && buf[3] > 0 && buf[3] < 5 && buf[4] == 0 { //ID3 tag found, must be a raw stream
 290             br.read_skip(6).unwrap();
 291             let mut size = 0;
 292             for _ in 0..4 {
 293                 let b = br.read_byte().unwrap();
 294                 if (b & 0x80) != 0 {
 295                     println!("Invalid ID3 size");
 296                     break;
 297                 }
 298                 size = (size << 7) | u64::from(b);
 299             }
 300             start += size + 10;
 301             br.read_skip(size as usize).unwrap();
 302             while let Ok(0) = br.read_byte() {
 303                 start += 1;
 304             }
 305             br.seek(SeekFrom::Start(start)).unwrap();
 306             is_raw = true;
 307         } else {
 308             break;
 309         }
 310     }
 311     // check for ID3v1
 312     br.seek(SeekFrom::End(-128)).unwrap();
 313     let off = br.tell();
 314     br.peek_buf(&mut buf[..3]).unwrap();
 315     if &buf[0..3] == b"TAG" {
 316         end = Some(off);
 317         // check for Lyrics v2
 318         let mut sig = [0; 9];
 319         br.seek(SeekFrom::End(-128 - 9)).unwrap();
 320         br.peek_buf(&mut sig).unwrap();
 321         if &sig == b"LYRICS200" {
 322             br.seek(SeekFrom::Current(-6)).unwrap();
 323             let mut sizestr = [0; 6];
 324             br.peek_buf(&mut sizestr).unwrap();
 325             if let Ok(sstr) = std::str::from_utf8(&sizestr) {
 326                 if let Ok(size) = sstr.parse::<u64>() {
 327                     end = Some(br.tell() - size);
 328                 }
 329             }
 330         }
 331     }
 332     // check for APETAG
 333     let mut buf = [0; 8];
 334     if let Some(off) = end {
 335         br.seek(SeekFrom::Start(off - 32)).unwrap();
 336     } else {
 337         br.seek(SeekFrom::End(-32)).unwrap();
 338     }
 339     let off = br.tell();
 340     br.read_buf(&mut buf).unwrap();
 341     if &buf == b"APETAGEX" {
 342         let ver     = br.read_u32le().unwrap();
 343         let size    = u64::from(br.read_u32le().unwrap());
 344         let _items  = br.read_u32le().unwrap();
 345         let flags   = br.read_u32le().unwrap();
 346         if ver == 1000 || (flags & 0x80000000) == 0 {
 347             end = Some(off - size + 32);
 348         } else {
 349             end = Some(off - size);
 350         }
 351     }
 352
 353     (is_raw, start, end)
 354 }