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.peek_buf(&mut buf).unwrap();
 130         let mut pname = "";
 131
 132         for pinfo in reg.pkt_reg.iter() {
 133             let mut packetiser = (pinfo.get_packetiser)();
 134             packetiser.add_data(&buf[..size]);
 135             if packetiser.parse_stream(0).is_ok() {
 136                 pname = pinfo.name;
 137                 break;
 138             }
 139         }
 140         if pname != "" {
 141             println!("found raw stream of type {} for {}", pname, name);
 142             let pcreate = reg.pkt_reg.find_packetiser(pname).unwrap();
 143             let mut packetiser = (pcreate)();
 144             packetiser.add_data(&buf[..size]);
 145             let stream = packetiser.parse_stream(0).unwrap();
 146             packetiser.reset();
 147             DemuxerObject::RawStream(RawStreamCtx::new(stream, packetiser, br))
 148         } else {
 149             DemuxerObject::None
 150         }
 151     }
 152     pub fn is_none(&self) -> bool {
 153         match *self {
 154             DemuxerObject::None => true,
 155             _ => false,
 156         }
 157     }
 158     pub fn get_duration(&self) -> u64 {
 159         match *self {
 160             DemuxerObject::Normal(ref dmx) => dmx.get_duration(),
 161             DemuxerObject::Raw(ref dmx, _, _) => dmx.get_duration(),
 162             _ => 0,
 163         }
 164     }
 165     pub fn get_num_streams(&self) -> usize {
 166         match *self {
 167             DemuxerObject::None => 0,
 168             DemuxerObject::Normal(ref dmx) => dmx.get_num_streams(),
 169             DemuxerObject::Raw(ref dmx, _, _) => dmx.get_num_streams(),
 170             DemuxerObject::RawStream(_) => 1,
 171         }
 172     }
 173     pub fn get_stream(&self, idx: usize) -> Option<NAStreamRef> {
 174         match *self {
 175             DemuxerObject::Normal(ref dmx) => dmx.get_stream(idx),
 176             DemuxerObject::Raw(ref dmx, _, _) => dmx.get_stream(idx),
 177             DemuxerObject::RawStream(ref ctx) if idx == 0 => Some(ctx.stream.clone()),
 178             _ => None,
 179         }
 180     }
 181     pub fn get_frame(&mut self) -> DemuxerResult<NAPacket> {
 182         match *self {
 183             DemuxerObject::Normal(ref mut dmx) => dmx.get_frame(),
 184             DemuxerObject::Raw(ref mut dmx, ref mut packetisers, ref mut eof) => {
 185                 loop {
 186                     let mut has_some = false;
 187                     for (stream, p) in dmx.get_streams().zip(packetisers.iter_mut()) {
 188                         if let Some(ref mut pkts) = p {
 189                             match pkts.get_packet(stream.clone()) {
 190                                 Ok(Some(pkt)) => return Ok(pkt),
 191                                 Ok(None) | Err(DecoderError::ShortData) => {
 192                                     if *eof {
 193                                         *p = None;
 194                                     }
 195                                 },
 196                                 Err(err) => {
 197                                     println!("packetisation error {:?}", err);
 198                                     return Err(DemuxerError::InvalidData);
 199                                 }
 200                             };
 201                             has_some |= p.is_some();
 202                         }
 203                     }
 204                     if !has_some {
 205                         return Err(DemuxerError::EOF);
 206                     }
 207                     if let Ok(data) = dmx.get_data() {
 208                         let id = data.get_stream().get_id();
 209                         for (i, stream) in dmx.get_streams().enumerate() {
 210                             if stream.get_id() == id {
 211                                 if let Some(ref mut pkts) = packetisers[i] {
 212                                     pkts.add_data(&data.get_buffer());
 213                                 }
 214                                 break;
 215                             }
 216                         }
 217                     } else {
 218                         *eof = true;
 219                     }
 220                 }
 221             },
 222             DemuxerObject::RawStream(ref mut ctx) => ctx.get_frame(),
 223             _ => unreachable!(),
 224         }
 225     }
 226     pub fn seek(&mut self, seek_time: NATimePoint) -> DemuxerResult<()> {
 227         match *self {
 228             DemuxerObject::Normal(ref mut dmx) => dmx.seek(seek_time),
 229             DemuxerObject::Raw(ref mut dmx, _, _) => dmx.seek(seek_time),
 230             DemuxerObject::RawStream(ref mut ctx) => {
 231                 if seek_time == NATimePoint::None {
 232                     return Err(DemuxerError::SeekError);
 233                 }
 234                 if let Some(last) = ctx.seek.seek_info[0].entries.last() {
 235                     let in_index = match seek_time {
 236                             NATimePoint::None => unreachable!(),
 237                             NATimePoint::PTS(pts) => last.pts >= pts,
 238                             NATimePoint::Milliseconds(ms) => last.time >= ms,
 239                         };
 240                     if in_index {
 241                         if let Some(result) = ctx.seek.find_pos(seek_time) {
 242                             ctx.br.seek(SeekFrom::Start(result.pos))?;
 243                             ctx.pts = result.pts;
 244                             ctx.pkt.reset();
 245                             return Ok(());
 246                         }
 247                     }
 248                 }
 249                 if let Some(last) = ctx.seek.seek_info[0].entries.last() {
 250                     ctx.br.seek(SeekFrom::Start(last.pos))?;
 251                     ctx.pts = last.pts;
 252                     ctx.pkt.reset();
 253                 }
 254                 let mut key_pts = 0;
 255                 while let Ok(pkt) = ctx.get_frame() {
 256                     if !pkt.ts.less_than(seek_time) && !pkt.ts.equal(seek_time) {
 257                         break;
 258                     }
 259                     if pkt.is_keyframe() {
 260                         key_pts = pkt.get_pts().unwrap_or(0);
 261                     }
 262                 }
 263                 let result = ctx.seek.find_pos(NATimePoint::PTS(key_pts)).unwrap();
 264                 ctx.br.seek(SeekFrom::Start(result.pos))?;
 265                 ctx.pts = result.pts;
 266                 ctx.pkt.reset();
 267                 Ok(())
 268             },
 269             _ => Err(DemuxerError::NotImplemented),
 270         }
 271     }
 272 }
 273
 274 pub fn detect_tags(br: &mut ByteReader) -> (bool, u64, Option<u64>) {
 275     let mut is_raw = false;
 276     let mut start = 0;
 277     let mut end = None;
 278
 279     // check for ID3v{2-4}
 280     let mut buf = [0; 5];
 281     br.peek_buf(&mut buf).unwrap();
 282     if &buf[0..3] == b"ID3" && buf[3] > 0 && buf[3] < 5 && buf[4] == 0 { //ID3 tag found, must be a raw stream
 283         br.read_skip(6).unwrap();
 284         let mut size = 0;
 285         for _ in 0..4 {
 286             let b = br.read_byte().unwrap();
 287             if (b & 0x80) != 0 {
 288                 println!("Invalid ID3 size");
 289                 break;
 290             }
 291             size = (size << 7) | u64::from(b);
 292         }
 293         start = size + 10;
 294         is_raw = true;
 295     }
 296     // check for ID3v1
 297     br.seek(SeekFrom::End(-128)).unwrap();
 298     let off = br.tell();
 299     br.peek_buf(&mut buf[..3]).unwrap();
 300     if &buf[0..3] == b"TAG" {
 301         end = Some(off);
 302     }
 303     // check for APETAG
 304     let mut buf = [0; 8];
 305     if let Some(off) = end {
 306         br.seek(SeekFrom::Start(off - 32)).unwrap();
 307     } else {
 308         br.seek(SeekFrom::End(-32)).unwrap();
 309     }
 310     let off = br.tell();
 311     br.read_buf(&mut buf).unwrap();
 312     if &buf == b"APETAGEX" {
 313         let ver     = br.read_u32le().unwrap();
 314         let size    = u64::from(br.read_u32le().unwrap());
 315         let _items  = br.read_u32le().unwrap();
 316         let flags   = br.read_u32le().unwrap();
 317         if ver == 1000 || (flags & 0x80000000) == 0 {
 318             end = Some(off - size + 32);
 319         } else {
 320             end = Some(off - size);
 321         }
 322     }
 323
 324     (is_raw, start, end)
 325 }