AVI demuxer

[nihav.git] / src / demuxers / mod.rs

diff --git a/src/demuxers/mod.rs b/src/demuxers/mod.rs
index 1eb6cd13874411b34d417ff180b7e52f17037e02..159002495d1c93b0e2e7dbc548dd34872ba4b31d 100644 (file)
--- a/src/demuxers/mod.rs
+++ b/src/demuxers/mod.rs
@@ -1,4 +1,5 @@
 pub mod gdv;
+pub mod avi;
 
 use std::fmt;
 use std::rc::Rc;
@@ -6,13 +7,14 @@ use frame::*;
 //use std::collections::HashMap;
 use io::byteio::*;
 
-#[derive(Debug)]
+#[derive(Debug,Clone,Copy)]
 #[allow(dead_code)]
 pub enum StreamType {
     Video,
     Audio,
     Subtitles,
     Data,
+    None,
 }
 
 impl fmt::Display for StreamType {
@@ -22,29 +24,34 @@ impl fmt::Display for StreamType {
             StreamType::Audio => write!(f, "Audio"),
             StreamType::Subtitles => write!(f, "Subtitles"),
             StreamType::Data => write!(f, "Data"),
+            StreamType::None => write!(f, "-"),
         }
     }
 }
 
 
 #[allow(dead_code)]
+#[derive(Clone)]
 pub struct NAStream {
     media_type:     StreamType,
     id:             u32,
+    num:            usize,
     info:           Rc<NACodecInfo>,
 }
 
 impl NAStream {
     pub fn new(mt: StreamType, id: u32, info: NACodecInfo) -> Self {
-        NAStream { media_type: mt, id: id, info: Rc::new(info) }
+        NAStream { media_type: mt, id: id, num: 0, info: Rc::new(info) }
     }
     pub fn get_id(&self) -> u32 { self.id }
+    pub fn get_num(&self) -> usize { self.num }
+    pub fn set_num(&mut self, num: usize) { self.num = num; }
     pub fn get_info(&self) -> Rc<NACodecInfo> { self.info.clone() }
 }
 
 impl fmt::Display for NAStream {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f, "({}#{})", self.media_type, self.id)
+        write!(f, "({}#{} - {})", self.media_type, self.id, self.info.get_properties())
     }
 }
 
@@ -95,7 +102,7 @@ pub enum DemuxerError {
 
 type DemuxerResult<T> = Result<T, DemuxerError>;
 
-pub trait NADemuxer<'a> {
+pub trait Demux<'a> {
     fn open(&mut self) -> DemuxerResult<()>;
     fn get_frame(&mut self) -> DemuxerResult<NAPacket>;
     fn seek(&mut self, time: u64) -> DemuxerResult<()>;
@@ -113,7 +120,6 @@ impl<'a> NAPacketReader for ByteReader<'a> {
         buf.resize(size, 0);
         let res = self.read_buf(buf.as_mut_slice());
         if let Err(_) = res { return Err(DemuxerError::IOError); }
-        if res.unwrap() < buf.len() { return Err(DemuxerError::IOError); }
         let pkt = NAPacket::new(str, pts, dts, dur, kf, buf);
         Ok(pkt)
     }
@@ -122,21 +128,47 @@ impl<'a> NAPacketReader for ByteReader<'a> {
         let mut buf = Rc::make_mut(&mut refbuf);
         let res = self.read_buf(buf.as_mut_slice());
         if let Err(_) = res { return Err(DemuxerError::IOError); }
-        if res.unwrap() < buf.len() { return Err(DemuxerError::IOError); }
         Ok(())
     }
 }
 
-pub struct NADemuxerBuilder {
+pub struct Demuxer {
+    streams: Vec<Rc<NAStream>>,
+}
+
+impl Demuxer {
+    pub fn new() -> Self { Demuxer { streams: Vec::new() } }
+    pub fn add_stream(&mut self, stream: NAStream) -> Option<usize> {
+        let stream_num = self.streams.len();
+        let mut str = stream.clone();
+        str.set_num(stream_num);
+        self.streams.push(Rc::new(str));
+        Some(stream_num)
+    }
+    pub fn get_stream(&self, idx: usize) -> Option<Rc<NAStream>> {
+        if idx < self.streams.len() {
+            Some(self.streams[idx].clone())
+        } else {
+            None
+        }
+    }
+    pub fn get_stream_by_id(&self, id: u32) -> Option<Rc<NAStream>> {
+        for i in 0..self.streams.len() {
+            if self.streams[i].get_id() == id {
+                return Some(self.streams[i].clone());
+            }
+        }
+        None
+    }
 }
 
 impl From<ByteIOError> for DemuxerError {
     fn from(_: ByteIOError) -> Self { DemuxerError::IOError }
 }
 
-impl NADemuxerBuilder {
-    #[allow(unused_variables)]
-    pub fn create_demuxer(name: &str, url: &str) -> DemuxerResult<Box<NADemuxer<'static>>> {
-        unimplemented!()
-    }
-}
+//impl NADemuxerBuilder {
+//    #[allow(unused_variables)]
+//    pub fn create_demuxer(name: &str, url: &str) -> DemuxerResult<Box<NADemuxer<'static>>> {
+//        unimplemented!()
+//    }
+//}