2 use nihav_core::codecs::*;
3 use nihav_core::demuxers::*;
4 use nihav_core::muxers::*;
5 use nihav_registry::detect;
6 use nihav_core::io::byteio::ByteReader;
10 use crate::{SBBox, SelfBorrow};
12 pub struct FullRegister {
13 pub dmx_reg: RegisteredDemuxers,
14 pub rdmx_reg: RegisteredRawDemuxers,
15 pub pkt_reg: RegisteredPacketisers,
16 pub dec_reg: RegisteredDecoders,
17 pub enc_reg: RegisteredEncoders,
18 pub mux_reg: RegisteredMuxers,
22 pub fn new() -> Self {
23 let mut dmx_reg = RegisteredDemuxers::new();
24 nihav_register_all_demuxers(&mut dmx_reg);
25 let mut rdmx_reg = RegisteredRawDemuxers::new();
26 nihav_register_all_raw_demuxers(&mut rdmx_reg);
27 let mut dec_reg = RegisteredDecoders::new();
28 nihav_register_all_decoders(&mut dec_reg);
29 let mut pkt_reg = RegisteredPacketisers::new();
30 nihav_register_all_packetisers(&mut pkt_reg);
31 let mut enc_reg = RegisteredEncoders::new();
32 nihav_register_all_encoders(&mut enc_reg);
33 enc_reg.add_encoder(NULL_ENCODER);
34 let mut mux_reg = RegisteredMuxers::new();
35 nihav_register_all_muxers(&mut mux_reg);
36 mux_reg.add_muxer(NULL_MUXER);
37 Self { dmx_reg, rdmx_reg, pkt_reg, dec_reg, enc_reg, mux_reg }
41 pub struct RawStreamCtx<'a> {
44 packetiser: Box<dyn NAPacketiser + Send>,
45 br: &'a mut ByteReader<'a>,
49 impl<'a> RawStreamCtx<'a> {
50 fn new(stream: NAStreamRef, packetiser: Box<dyn NAPacketiser + Send>, br: &'a mut ByteReader<'a>) -> Self {
51 let mut sm = StreamManager::new();
52 sm.add_stream_ref(stream.clone());
53 Self { stream, sm, packetiser, br, pts: 0 }
57 type ReaderBox<'a> = SBBox<Box<dyn ByteIO>, ByteReader<'a>>;
59 pub enum DemuxerObject<'a> {
61 Normal(SBBox<ReaderBox<'a>, Demuxer<'a>>),
62 Raw(SBBox<ReaderBox<'a>, RawDemuxer<'a>>, Vec<Option<Box<dyn NAPacketiser + Send>>>, bool),
63 RawStream(SBBox<ReaderBox<'a>, RawStreamCtx<'a>>),
64 ImageSequence(ImgSeqDemuxer),
67 impl<'a> DemuxerObject<'a> {
68 pub fn create(mut brb: ReaderBox<'a>, reg: &FullRegister, name: &str, ifmt: &Option<String>, is_raw: bool, print_info: bool) -> DemuxerObject<'a> {
69 let br = brb.get_object_mut();
71 let dmx_name = if let Some(ref dname) = ifmt {
73 } else if let Some((dname, score)) = detect::detect_format(name, br) {
75 println!("detected {} with score {:?}", dname, score);
81 if !dmx_name.is_empty() {
83 println!("trying demuxer {} on {}", dmx_name, name);
85 if let Some(dmx_fact) = reg.dmx_reg.find_demuxer(dmx_name) {
86 br.seek(SeekFrom::Start(0)).unwrap();
88 let dmx = SelfBorrow::new(brb, |br_| {
90 create_demuxer(dmx_fact, br_.as_mut().unwrap().get_object_mut()).unwrap()
93 return DemuxerObject::Normal(dmx);
97 return DemuxerObject::None;
99 if !dmx_name.is_empty() {
101 println!("trying raw demuxer {} on {}", dmx_name, name);
103 if let Some(rdmx_fact) = reg.rdmx_reg.find_demuxer(dmx_name) {
104 br.seek(SeekFrom::Start(0)).unwrap();
105 let dmx = SelfBorrow::new(brb, |br_| {
107 create_raw_demuxer(rdmx_fact, br_.as_mut().unwrap().get_object_mut()).unwrap()
110 let mut pkts = Vec::new();
111 for stream in dmx.get_object().get_streams() {
112 if let Some(pcreate) = reg.pkt_reg.find_packetiser(stream.get_info().get_name()) {
113 let packetiser = (pcreate)();
114 pkts.push(Some(packetiser));
119 return DemuxerObject::Raw(dmx, pkts, false);
122 for rdmx in reg.rdmx_reg.iter() {
123 if rdmx.check_format(br) {
125 println!("detected {} as {}", name, rdmx.get_name());
127 br.seek(SeekFrom::Start(0)).unwrap();
128 let dmx = SelfBorrow::new(brb, |br_| {
130 create_raw_demuxer(*rdmx, br_.as_mut().unwrap().get_object_mut()).unwrap()
133 let mut pkts = Vec::new();
134 for stream in dmx.get_object().get_streams() {
135 if let Some(pcreate) = reg.pkt_reg.find_packetiser(stream.get_info().get_name()) {
136 let packetiser = (pcreate)();
137 pkts.push(Some(packetiser));
142 return DemuxerObject::Raw(dmx, pkts, false);
146 br.seek(SeekFrom::Start(0)).unwrap();
147 let mut buf = vec![0; 1048576];
148 let size = br.peek_buf(&mut buf).unwrap();
151 for pinfo in reg.pkt_reg.iter() {
152 let mut packetiser = (pinfo.get_packetiser)();
153 packetiser.add_data(&buf[..size]);
154 if packetiser.parse_stream(0).is_ok() {
159 if !pname.is_empty() {
161 println!("found raw stream of type {} for {}", pname, name);
163 let pcreate = reg.pkt_reg.find_packetiser(pname).unwrap();
164 let rctx = SelfBorrow::new(brb, |br_| {
166 let mut packetiser = (pcreate)();
167 packetiser.add_data(&buf[..size]);
168 let stream = packetiser.parse_stream(0).unwrap();
170 RawStreamCtx::new(stream, packetiser, br_.as_mut().unwrap().get_object_mut())
173 DemuxerObject::RawStream(rctx)
178 pub fn create_imgseq(isd: ImgSeqDemuxer) -> Self {
179 DemuxerObject::ImageSequence(isd)
181 pub fn is_none(&self) -> bool {
182 matches!(*self, DemuxerObject::None)
184 pub fn get_duration(&self) -> u64 {
186 DemuxerObject::Normal(ref dmx) => dmx.get_object().get_duration(),
187 DemuxerObject::Raw(ref dmx, _, _) => dmx.get_object().get_duration(),
188 DemuxerObject::RawStream(ref ctx) => {
189 NATimeInfo::ts_to_time(ctx.get_object().stream.duration, 1000, ctx.get_object().stream.tb_num, ctx.get_object().stream.tb_den)
194 pub fn get_num_streams(&self) -> usize {
196 DemuxerObject::None => 0,
197 DemuxerObject::Normal(ref dmx) => dmx.get_object().get_num_streams(),
198 DemuxerObject::Raw(ref dmx, _, _) => dmx.get_object().get_num_streams(),
199 DemuxerObject::RawStream(_) => 1,
200 DemuxerObject::ImageSequence(_) => 1,
203 pub fn get_stream(&self, idx: usize) -> Option<NAStreamRef> {
205 DemuxerObject::Normal(ref dmx) => dmx.get_object().get_stream(idx),
206 DemuxerObject::Raw(ref dmx, _, _) => dmx.get_object().get_stream(idx),
207 DemuxerObject::RawStream(ref ctx) if idx == 0 => Some(ctx.get_object().stream.clone()),
208 DemuxerObject::ImageSequence(ref ctx) if idx == 0 => Some(ctx.stream.clone()),
212 /*pub fn get_streams(&self) -> StreamIter {
214 DemuxerObject::Normal(ref dmx) => dmx.get_object().get_streams(),
215 DemuxerObject::Raw(ref dmx, _, _) => dmx.get_object().get_streams(),
216 DemuxerObject::RawStream(ref ctx) => ctx.get_object().sm.iter(),
217 DemuxerObject::ImageSequence(ref ctx) => ctx.sm.iter(),
221 pub fn get_stream_manager(&self) -> &StreamManager {
223 DemuxerObject::Normal(ref dmx) => dmx.get_object().get_stream_manager(),
224 DemuxerObject::Raw(ref dmx, _, _) => dmx.get_object().get_stream_manager(),
225 DemuxerObject::RawStream(ref ctx) => &ctx.get_object().sm,
226 DemuxerObject::ImageSequence(ref ctx) => &ctx.sm,
230 pub fn get_frame(&mut self) -> DemuxerResult<NAPacket> {
232 DemuxerObject::Normal(ref mut dmx) => dmx.get_object_mut().get_frame(),
233 DemuxerObject::Raw(ref mut dmx, ref mut packetisers, ref mut eof) => {
234 let dmx = dmx.get_object_mut();
236 let mut has_some = false;
237 for (stream, p) in dmx.get_streams().zip(packetisers.iter_mut()) {
238 if let Some(ref mut pkts) = p {
239 match pkts.get_packet(stream.clone()) {
240 Ok(Some(pkt)) => return Ok(pkt),
241 Ok(None) | Err(DecoderError::ShortData) => {
247 println!("packetisation error {:?}", err);
248 return Err(DemuxerError::InvalidData);
251 has_some |= p.is_some();
255 return Err(DemuxerError::EOF);
257 if let Ok(data) = dmx.get_data() {
258 let id = data.get_stream().get_id();
259 for (i, stream) in dmx.get_streams().enumerate() {
260 if stream.get_id() == id {
261 if let Some(ref mut pkts) = packetisers[i] {
262 pkts.add_data(&data.get_buffer());
272 DemuxerObject::RawStream(ref mut ctx) => {
273 let ctx = ctx.get_object_mut();
274 let mut buf = [0; 65536];
276 match ctx.packetiser.get_packet(ctx.stream.clone()) {
277 Ok(Some(mut packet)) => {
278 if packet.get_pts().is_none() && packet.get_duration().is_some() {
279 packet.ts.pts = Some(ctx.pts);
281 ctx.pts += packet.get_duration().unwrap_or(0);
285 Err(DecoderError::ShortData) => {},
286 _ => return Err(DemuxerError::InvalidData),
288 match ctx.br.read_buf_some(&mut buf) {
290 ctx.packetiser.add_data(&buf[..size]);
293 match ctx.packetiser.get_packet(ctx.stream.clone()) {
294 Ok(Some(mut packet)) => {
295 if packet.get_pts().is_none() && packet.get_duration().is_some() {
296 packet.ts.pts = Some(ctx.pts);
298 ctx.pts += packet.get_duration().unwrap_or(0);
301 Ok(None) | Err(DecoderError::ShortData) => return Err(DemuxerError::EOF),
302 _ => return Err(DemuxerError::InvalidData),
308 DemuxerObject::ImageSequence(ref mut ctx) => ctx.get_frame(),
312 pub fn seek(&mut self, seek_time: NATimePoint) -> DemuxerResult<()> {
314 DemuxerObject::Normal(ref mut dmx) => dmx.get_object_mut().seek(seek_time),
315 DemuxerObject::Raw(ref mut dmx, _, _) => dmx.get_object_mut().seek(seek_time),
316 DemuxerObject::ImageSequence(ref mut ctx) => ctx.seek(seek_time),
317 _ => Err(DemuxerError::NotImplemented),
322 impl<'a> NAOptionHandler for DemuxerObject<'a> {
323 fn get_supported_options(&self) -> &[NAOptionDefinition] {
325 DemuxerObject::Normal(ref dmx) => dmx.get_object().get_supported_options(),
326 DemuxerObject::Raw(ref dmx, _, _) => dmx.get_object().get_supported_options(),
327 DemuxerObject::ImageSequence(ref ctx) => ctx.get_supported_options(),
331 fn set_options(&mut self, options: &[NAOption]) {
333 DemuxerObject::Normal(ref mut dmx) => dmx.get_object_mut().set_options(options),
334 DemuxerObject::Raw(ref mut dmx, _, _) => dmx.get_object_mut().set_options(options),
335 DemuxerObject::ImageSequence(ref mut ctx) => ctx.set_options(options),
339 fn query_option_value(&self, name: &str) -> Option<NAValue> {
341 DemuxerObject::Normal(ref dmx) => dmx.get_object().query_option_value(name),
342 DemuxerObject::Raw(ref dmx, _, _) => dmx.get_object().query_option_value(name),
343 DemuxerObject::ImageSequence(ref ctx) => ctx.query_option_value(name),
349 pub fn detect_tags(br: &mut ByteReader) -> (bool, u64, Option<u64>) {
350 let mut is_raw = false;
354 // check for ID3v{2-4}
355 let mut buf = [0; 5];
356 br.peek_buf(&mut buf).unwrap();
357 if &buf[0..3] == b"ID3" && buf[3] > 0 && buf[3] < 5 && buf[4] == 0 { //ID3 tag found, must be a raw stream
358 br.read_skip(6).unwrap();
361 let b = br.read_byte().unwrap();
363 println!("Invalid ID3 size");
366 size = (size << 7) | u64::from(b);
372 br.seek(SeekFrom::End(-128)).unwrap();
374 br.peek_buf(&mut buf[..3]).unwrap();
375 if &buf[0..3] == b"TAG" {
379 let mut buf = [0; 8];
380 if let Some(off) = end {
381 br.seek(SeekFrom::Start(off - 32)).unwrap();
383 br.seek(SeekFrom::End(-32)).unwrap();
386 br.read_buf(&mut buf).unwrap();
387 if &buf == b"APETAGEX" {
388 let ver = br.read_u32le().unwrap();
389 let size = u64::from(br.read_u32le().unwrap());
390 let _items = br.read_u32le().unwrap();
391 let flags = br.read_u32le().unwrap();
392 if ver == 1000 || (flags & 0x80000000) == 0 {
393 end = Some(off - size + 32);
395 end = Some(off - size);