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 pub struct FullRegister {
11 pub dmx_reg: RegisteredDemuxers,
12 pub rdmx_reg: RegisteredRawDemuxers,
13 pub pkt_reg: RegisteredPacketisers,
14 pub dec_reg: RegisteredDecoders,
15 pub enc_reg: RegisteredEncoders,
16 pub mux_reg: RegisteredMuxers,
20 pub fn new() -> Self {
21 let mut dmx_reg = RegisteredDemuxers::new();
22 nihav_register_all_demuxers(&mut dmx_reg);
23 let mut rdmx_reg = RegisteredRawDemuxers::new();
24 nihav_register_all_raw_demuxers(&mut rdmx_reg);
25 let mut dec_reg = RegisteredDecoders::new();
26 nihav_register_all_decoders(&mut dec_reg);
27 let mut pkt_reg = RegisteredPacketisers::new();
28 nihav_register_all_packetisers(&mut pkt_reg);
29 let mut enc_reg = RegisteredEncoders::new();
30 nihav_register_all_encoders(&mut enc_reg);
31 enc_reg.add_encoder(NULL_ENCODER);
32 let mut mux_reg = RegisteredMuxers::new();
33 nihav_register_all_muxers(&mut mux_reg);
34 mux_reg.add_muxer(NULL_MUXER);
35 Self { dmx_reg, rdmx_reg, pkt_reg, dec_reg, enc_reg, mux_reg }
39 pub struct RawStreamCtx<'a> {
42 packetiser: Box<dyn NAPacketiser + Send>,
43 br: &'a mut ByteReader<'a>,
47 impl<'a> RawStreamCtx<'a> {
48 fn new(stream: NAStreamRef, packetiser: Box<dyn NAPacketiser + Send>, br: &'a mut ByteReader<'a>) -> Self {
49 let mut sm = StreamManager::new();
50 sm.add_stream_ref(stream.clone());
51 Self { stream, sm, packetiser, br, pts: 0 }
55 pub enum DemuxerObject<'a> {
58 Raw(RawDemuxer<'a>, Vec<Option<Box<dyn NAPacketiser + Send>>>, bool),
59 RawStream(RawStreamCtx<'a>),
62 impl<'a> DemuxerObject<'a> {
63 pub fn create(br: &'a mut ByteReader<'a>, reg: &FullRegister, name: &str, ifmt: &Option<String>, is_raw: bool) -> DemuxerObject<'a> {
65 let dmx_name = if let Some(ref dname) = ifmt {
67 } else if let Some((dname, score)) = detect::detect_format(name, br) {
68 println!("detected {} with score {:?}", dname, score);
74 println!("trying demuxer {} on {}", dmx_name, name);
75 if let Some(dmx_fact) = reg.dmx_reg.find_demuxer(dmx_name) {
76 br.seek(SeekFrom::Start(0)).unwrap();
77 let dmx = create_demuxer(dmx_fact, br).unwrap();
78 return DemuxerObject::Normal(dmx);
82 return DemuxerObject::None;
85 println!("trying raw demuxer {} on {}", dmx_name, name);
86 if let Some(rdmx_fact) = reg.rdmx_reg.find_demuxer(dmx_name) {
87 br.seek(SeekFrom::Start(0)).unwrap();
88 let dmx = create_raw_demuxer(rdmx_fact, br).unwrap();
89 let mut pkts = Vec::new();
90 for stream in dmx.get_streams() {
91 if let Some(pcreate) = reg.pkt_reg.find_packetiser(stream.get_info().get_name()) {
92 let packetiser = (pcreate)();
93 pkts.push(Some(packetiser));
98 return DemuxerObject::Raw(dmx, pkts, false);
101 for rdmx in reg.rdmx_reg.iter() {
102 if rdmx.check_format(br) {
103 println!("detected {} as {}", name, rdmx.get_name());
104 br.seek(SeekFrom::Start(0)).unwrap();
105 let dmx = create_raw_demuxer(*rdmx, br).unwrap();
106 let mut pkts = Vec::new();
107 for stream in dmx.get_streams() {
108 if let Some(pcreate) = reg.pkt_reg.find_packetiser(stream.get_info().get_name()) {
109 let packetiser = (pcreate)();
110 pkts.push(Some(packetiser));
115 return DemuxerObject::Raw(dmx, pkts, false);
119 br.seek(SeekFrom::Start(0)).unwrap();
120 let mut buf = vec![0; 1048576];
121 let size = br.peek_buf(&mut buf).unwrap();
124 for pinfo in reg.pkt_reg.iter() {
125 let mut packetiser = (pinfo.get_packetiser)();
126 packetiser.add_data(&buf[..size]);
127 if packetiser.parse_stream(0).is_ok() {
133 println!("found raw stream of type {} for {}", pname, name);
134 let pcreate = reg.pkt_reg.find_packetiser(pname).unwrap();
135 let mut packetiser = (pcreate)();
136 packetiser.add_data(&buf[..size]);
137 let stream = packetiser.parse_stream(0).unwrap();
139 DemuxerObject::RawStream(RawStreamCtx::new(stream, packetiser, br))
144 pub fn is_none(&self) -> bool {
146 DemuxerObject::None => true,
150 pub fn get_duration(&self) -> u64 {
152 DemuxerObject::Normal(ref dmx) => dmx.get_duration(),
153 DemuxerObject::Raw(ref dmx, _, _) => dmx.get_duration(),
157 pub fn get_num_streams(&self) -> usize {
159 DemuxerObject::None => 0,
160 DemuxerObject::Normal(ref dmx) => dmx.get_num_streams(),
161 DemuxerObject::Raw(ref dmx, _, _) => dmx.get_num_streams(),
162 DemuxerObject::RawStream(_) => 1,
165 pub fn get_stream(&self, idx: usize) -> Option<NAStreamRef> {
167 DemuxerObject::Normal(ref dmx) => dmx.get_stream(idx),
168 DemuxerObject::Raw(ref dmx, _, _) => dmx.get_stream(idx),
169 DemuxerObject::RawStream(ref ctx) if idx == 0 => Some(ctx.stream.clone()),
173 pub fn get_streams(&self) -> StreamIter {
175 DemuxerObject::Normal(ref dmx) => dmx.get_streams(),
176 DemuxerObject::Raw(ref dmx, _, _) => dmx.get_streams(),
177 DemuxerObject::RawStream(ref ctx) => ctx.sm.iter(),
181 pub fn get_stream_manager(&self) -> &StreamManager {
183 DemuxerObject::Normal(ref dmx) => dmx.get_stream_manager(),
184 DemuxerObject::Raw(ref dmx, _, _) => dmx.get_stream_manager(),
185 DemuxerObject::RawStream(ref ctx) => &ctx.sm,
189 pub fn get_frame(&mut self) -> DemuxerResult<NAPacket> {
191 DemuxerObject::Normal(ref mut dmx) => dmx.get_frame(),
192 DemuxerObject::Raw(ref mut dmx, ref mut packetisers, ref mut eof) => {
194 let mut has_some = false;
195 for (stream, p) in dmx.get_streams().zip(packetisers.iter_mut()) {
196 if let Some(ref mut pkts) = p {
197 match pkts.get_packet(stream.clone()) {
198 Ok(Some(pkt)) => return Ok(pkt),
199 Ok(None) | Err(DecoderError::ShortData) => {
205 println!("packetisation error {:?}", err);
206 return Err(DemuxerError::InvalidData);
209 has_some |= p.is_some();
213 return Err(DemuxerError::EOF);
215 if let Ok(data) = dmx.get_data() {
216 let id = data.get_stream().get_id();
217 for (i, stream) in dmx.get_streams().enumerate() {
218 if stream.get_id() == id {
219 if let Some(ref mut pkts) = packetisers[i] {
220 pkts.add_data(&data.get_buffer());
230 DemuxerObject::RawStream(ref mut ctx) => {
231 let mut buf = [0; 65536];
233 match ctx.packetiser.get_packet(ctx.stream.clone()) {
234 Ok(Some(mut packet)) => {
235 if packet.get_pts().is_none() && packet.get_duration().is_some() {
236 packet.ts.pts = Some(ctx.pts);
238 ctx.pts += packet.get_duration().unwrap_or(0);
242 Err(DecoderError::ShortData) => {},
243 _ => return Err(DemuxerError::InvalidData),
245 match ctx.br.read_buf_some(&mut buf) {
247 ctx.packetiser.add_data(&buf[..size]);
250 match ctx.packetiser.get_packet(ctx.stream.clone()) {
251 Ok(Some(mut packet)) => {
252 if packet.get_pts().is_none() && packet.get_duration().is_some() {
253 packet.ts.pts = Some(ctx.pts);
255 ctx.pts += packet.get_duration().unwrap_or(0);
258 Ok(None) | Err(DecoderError::ShortData) => return Err(DemuxerError::EOF),
259 _ => return Err(DemuxerError::InvalidData),
268 pub fn seek(&mut self, seek_time: NATimePoint) -> DemuxerResult<()> {
270 DemuxerObject::Normal(ref mut dmx) => dmx.seek(seek_time),
271 DemuxerObject::Raw(ref mut dmx, _, _) => dmx.seek(seek_time),
272 _ => Err(DemuxerError::NotImplemented),
277 impl<'a> NAOptionHandler for DemuxerObject<'a> {
278 fn get_supported_options(&self) -> &[NAOptionDefinition] {
280 DemuxerObject::Normal(ref dmx) => dmx.get_supported_options(),
281 DemuxerObject::Raw(ref dmx, _, _) => dmx.get_supported_options(),
285 fn set_options(&mut self, options: &[NAOption]) {
287 DemuxerObject::Normal(ref mut dmx) => dmx.set_options(options),
288 DemuxerObject::Raw(ref mut dmx, _, _) => dmx.set_options(options),
292 fn query_option_value(&self, name: &str) -> Option<NAValue> {
294 DemuxerObject::Normal(ref dmx) => dmx.query_option_value(name),
295 DemuxerObject::Raw(ref dmx, _, _) => dmx.query_option_value(name),
301 pub fn detect_tags(br: &mut ByteReader) -> (bool, u64, Option<u64>) {
302 let mut is_raw = false;
306 // check for ID3v{2-4}
307 let mut buf = [0; 5];
308 br.peek_buf(&mut buf).unwrap();
309 if &buf[0..3] == b"ID3" && buf[3] > 0 && buf[3] < 5 && buf[4] == 0 { //ID3 tag found, must be a raw stream
310 br.read_skip(6).unwrap();
313 let b = br.read_byte().unwrap();
315 println!("Invalid ID3 size");
318 size = (size << 7) | u64::from(b);
324 br.seek(SeekFrom::End(-128)).unwrap();
326 br.peek_buf(&mut buf[..3]).unwrap();
327 if &buf[0..3] == b"TAG" {
331 let mut buf = [0; 8];
332 if let Some(off) = end {
333 br.seek(SeekFrom::Start(off - 32)).unwrap();
335 br.seek(SeekFrom::End(-32)).unwrap();
338 br.read_buf(&mut buf).unwrap();
339 if &buf == b"APETAGEX" {
340 let ver = br.read_u32le().unwrap();
341 let size = u64::from(br.read_u32le().unwrap());
342 let _items = br.read_u32le().unwrap();
343 let flags = br.read_u32le().unwrap();
344 if ver == 1000 || (flags & 0x80000000) == 0 {
345 end = Some(off - size + 32);
347 end = Some(off - size);