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

use super::*;
use super::DemuxerError::*;
//use io::byteio::*;
//use frame::*;
use formats::*;
use std::io::SeekFrom;
use std::mem;

macro_rules! mktag {
    ($a:expr, $b:expr, $c:expr, $d:expr) => ({
        (($a as u32) << 24) | (($b as u32) << 16) | (($c as u32) << 8) | ($d as u32)
    });
    ($arr:expr) => ({
        (($arr[0] as u32) << 24) | (($arr[1] as u32) << 16) | (($arr[2] as u32) << 8) | ($arr[3] as u32)
    });
}

struct RMVideoStream {
    frame:      Vec<u8>,
    hdr_size:   usize,
    frame_size: usize,
    frame_pos:  usize,
}

impl RMVideoStream {
    fn new() -> Self {
        RMVideoStream {
            frame:      Vec::new(),
            hdr_size:   0,
            frame_size: 0,
            frame_pos:  0,
        }
    }
    fn flush(&mut self) {
        self.frame.truncate(0);
        self.frame_size = 0;
        self.frame_pos  = 0;
    }
    fn start_slice(&mut self, num_slices: usize, frame_size: usize, data: &[u8]) {
        self.hdr_size = num_slices * 8 + 1;
        self.frame.resize(frame_size + self.hdr_size, 0);
        self.frame[0] = (num_slices - 1) as u8;
        self.frame_pos = 0;
        self.add_slice(1, data);
    }
    fn add_slice(&mut self, slice_no: usize, data: &[u8]) {
        self.write_slice_info(slice_no);
        let mut dslice = &mut self.frame[self.hdr_size + self.frame_pos..][..data.len()];
        dslice.copy_from_slice(data);
        self.frame_pos += data.len();
    }
    fn write_slice_info(&mut self, slice_no: usize) {
        let off = 1 + (slice_no - 1) * 8;
        self.frame[off + 0] = 0;
        self.frame[off + 1] = 0;
        self.frame[off + 2] = 0;
        self.frame[off + 3] = 1;
        self.frame[off + 4] = (self.frame_pos >> 24) as u8;
        self.frame[off + 5] = (self.frame_pos >> 16) as u8;
        self.frame[off + 6] = (self.frame_pos >>  8) as u8;
        self.frame[off + 7] = (self.frame_pos >>  0) as u8;
    }
    fn get_frame_data(&mut self) -> Vec<u8> {
        let mut v: Vec<u8> = Vec::new();
        mem::swap(&mut v, &mut self.frame);
        self.flush();
        v
    }
}

#[derive(Clone,Copy,PartialEq)]
enum Deinterleaver {
    None,
    Generic,
    Sipro,
    VBR,
}

struct RMAudioStream {
    deint:      Deinterleaver,
}

impl RMAudioStream {
    fn new(deint: Deinterleaver) -> Self {
        RMAudioStream { deint: deint }
    }
}

enum RMStreamType {
    Audio(RMAudioStream),
    Video(RMVideoStream),
    Logical,
    Unknown,
}

struct RealMediaDemuxer<'a> {
    src:            &'a mut ByteReader<'a>,
    data_pos:       u64,
    num_packets:    u32,
    cur_packet:     u32,

    streams:        Vec<RMStreamType>,
    str_ids:        Vec<u16>,

    queued_pkts:    Vec<NAPacket>,
    slice_buf:      Vec<u8>,
}

fn find_codec_name(registry: &[(&[u8;4], &'static str)], fcc: u32) -> &'static str {
    for &(fourcc, name) in registry {
        if mktag!(fourcc) == fcc { return name; }
    }
    "unknown"
}

fn read_14or30(src: &mut ByteReader) -> DemuxerResult<(bool, u32)> {
    let tmp = src.read_u16be()?;
    let flag = (tmp & 0x8000) != 0;
    if (tmp & 0x4000) == 0x4000 {
        Ok((flag, ((tmp & 0x3FFF) as u32)))
    } else {
        let val = ((tmp as u32) << 16) | (src.read_u16be()? as u32);
        Ok((flag, val & 0x3FFFFFFF))
    }
}

fn read_video_buf(src: &mut ByteReader, stream: Rc<NAStream>, ts: u32, keyframe: bool, frame_size: usize) -> DemuxerResult<NAPacket> {
    let size = (frame_size as usize) + 9;
    let mut vec: Vec<u8> = Vec::with_capacity(size);
    vec.resize(size, 0);
    //v[0] = 0; // 1 slice
    vec[4] = 1;
    src.read_buf(&mut vec[9..])?;

    let (tb_num, tb_den) = stream.get_timebase();
    let ts = NATimeInfo::new(Some(ts as u64), None, None, tb_num, tb_den);
    Ok(NAPacket::new(stream, ts, keyframe, vec))
}

fn read_multiple_frame(src: &mut ByteReader, stream: Rc<NAStream>, keyframe: bool, skip_mtype: bool) -> DemuxerResult<NAPacket> {
    if !skip_mtype {
        let mtype       = src.read_byte()?;
        validate!(mtype == 0xC0);
    }
    let (_, frame_size) = read_14or30(src)?;
    let (_, timestamp)  = read_14or30(src)?;
    let seq_no          = src.read_byte()?;
println!("  multiple frame size {} ts {} seq {}", frame_size, timestamp, seq_no);

    read_video_buf(src, stream, timestamp, keyframe, frame_size as usize)
}

impl<'a> DemuxCore<'a> for RealMediaDemuxer<'a> {
    #[allow(unused_variables)]
    fn open(&mut self, strmgr: &mut StreamManager) -> DemuxerResult<()> {
        self.read_header(strmgr)?;
        Ok(())
    }

#[allow(unused_variables)]
    fn get_frame(&mut self, strmgr: &mut StreamManager) -> DemuxerResult<NAPacket> {
        if !self.queued_pkts.is_empty() {
            let pkt = self.queued_pkts.pop().unwrap();
            return Ok(pkt);
        }
        loop {
            if self.cur_packet >= self.num_packets { return Err(DemuxerError::EOF); }

            let pkt_start = self.src.tell();
            let ver             = self.src.read_u16le()?;
            validate!(ver <= 1);
            let len             = self.src.read_u16be()? as usize;
            let str_no          = self.src.read_u16be()?;
            let ts              = self.src.read_u32be()?;
            let pkt_grp;
            if ver == 0 {
                pkt_grp         = self.src.read_byte()?;
            } else {
                //asm_rule        = self.src.read_u16le()?;
                self.src.read_skip(2)?;
                pkt_grp = 0;
            }
            let flags           = self.src.read_byte()?;
            let hdr_size = self.src.tell() - pkt_start;
println!("packet @{:X} size {} for {} ts {} grp {} flags {:X}", pkt_start, len, str_no, ts, pkt_grp, flags);
            self.cur_packet += 1;

            let payload_size = len - (hdr_size as usize);

            let sr = self.str_ids.iter().position(|x| *x == str_no);
            if sr.is_none() {
println!("stream {} not found", str_no);
                self.src.read_skip(payload_size)?;
                return Err(DemuxerError::InvalidData);
            }
            let str_id = sr.unwrap();
            let stream = strmgr.get_stream_by_id(str_no as u32).unwrap();
println!("  stream {}", str_id);
            if strmgr.is_ignored_id(str_no as u32) {
                self.src.read_skip(payload_size)?;
                continue;
            }
            //todo skip unwanted packet
            let keyframe = (flags & KEYFRAME_FLAG) != 0;

            let result = match self.streams[str_id] {
                RMStreamType::Video(ref mut vstr) => {

                        let pos = self.src.tell();
                        let b0          = self.src.read_byte()?;
                        match b0 >> 6 {
                            0 => { // partial frame
                                    let b1  = self.src.read_byte()?;
                                    let hdr1 = ((b0 as u16) << 8) | (b1 as u16);
                                    let num_pkts = ((hdr1 >> 7) & 0x7F) as usize;
                                    let packet_num = hdr1 & 0x7F;
                                    let (_, frame_size) = read_14or30(self.src)?;
                                    let (_, off)        = read_14or30(self.src)?;
                                    let seq_no = self.src.read_byte()?;
println!(" mode 0 pkt {}/{} off {}/{} seq {}", packet_num, num_pkts, off, frame_size, seq_no);
                                    let hdr_skip = (self.src.tell() - pos) as usize;

                                    let slice_size = (payload_size - hdr_skip) as usize;
                                    self.slice_buf.resize(slice_size, 0);
                                    self.src.read_buf(self.slice_buf.as_mut_slice())?;
                                    if packet_num == 1 {
                                        vstr.start_slice(num_pkts, frame_size as usize, self.slice_buf.as_slice());
                                    } else {
                                        vstr.add_slice(packet_num as usize, self.slice_buf.as_slice()); 
                                    }
                                    continue;
                                },
                            1 => { // whole frame
                                    let seq_no = self.src.read_byte()?;
println!(" mode 1 seq {}", seq_no);
                                    read_video_buf(self.src, stream, ts, keyframe, payload_size - 1)
                                },
                            2 => { // last partial frame
                                    let b1  = self.src.read_byte()?;
                                    let hdr1 = ((b0 as u16) << 8) | (b1 as u16);
                                    let num_pkts = ((hdr1 >> 7) & 0x7F) as usize;
                                    let packet_num = hdr1 & 0x7F;
                                    let (_, frame_size) = read_14or30(self.src)?;
                                    let (_, tail_size)  = read_14or30(self.src)?;
                                    let seq_no = self.src.read_byte()?;
println!(" mode 2 pkt {}/{} tail {}/{} seq {}", packet_num, num_pkts, tail_size, frame_size, seq_no);
                                    self.slice_buf.resize(tail_size as usize, 0);
                                    self.src.read_buf(self.slice_buf.as_mut_slice())?;
                                    vstr.add_slice(packet_num as usize, self.slice_buf.as_slice());

                                    while self.src.tell() < pos + (payload_size as u64) {
                                        let res = read_multiple_frame(self.src, stream.clone(), false, false);
                                        if res.is_err() { break; }
                                        self.queued_pkts.push(res.unwrap());
                                    }
                                    self.queued_pkts.reverse();
                                    let (tb_num, tb_den) = stream.get_timebase();
                                    let ts = NATimeInfo::new(Some(ts as u64), None, None, tb_num, tb_den);
                                    let pkt = NAPacket::new(stream, ts, keyframe, vstr.get_frame_data());
                                    Ok(pkt)
                            },
                        _ => { // multiple frames
println!(" mode 3");
                                    let res = read_multiple_frame(self.src, stream.clone(), keyframe, true);
                                    if res.is_err() { return res; }
                                    while self.src.tell() < pos + (payload_size as u64) {
                                        let res = read_multiple_frame(self.src, stream.clone(), false, false);
                                        if res.is_err() { break; }
                                        self.queued_pkts.push(res.unwrap());
                                    }
                                    self.queued_pkts.reverse();
                                    res
                                },
                        }
                    },
                RMStreamType::Audio(ref mut astr) => {
                        let (tb_num, tb_den) = stream.get_timebase();
                        let ts = NATimeInfo::new(Some(ts as u64), None, None, tb_num, tb_den);
                        self.src.read_packet(stream, ts, keyframe, payload_size)
                    },
                _ => {
//                        self.src.read_skip(payload_size)?;
                        Err(DemuxerError::InvalidData)
                    },
            };
            return result;
        }
    }

    #[allow(unused_variables)]
    fn seek(&mut self, time: u64) -> DemuxerResult<()> {
        Err(NotImplemented)
    }
}

fn read_chunk(src: &mut ByteReader) -> DemuxerResult<(u32, u32, u16)> {
    let id      = src.read_u32be()?;
    let size    = src.read_u32be()?;
    validate!(size >= 10);
    let ver     = src.read_u16be()?;
    validate!(ver <= 1);
    Ok((id, size, ver))
}

const RMVB_HDR_SIZE:  u32 = 18;
const RMVB_PROP_SIZE: u32 = 50;
const KEYFRAME_FLAG: u8 = 0x02;

impl<'a> RealMediaDemuxer<'a> {
    fn new(io: &'a mut ByteReader<'a>) -> Self {
        RealMediaDemuxer {
            src:            io,
            data_pos:       0,
            num_packets:    0,
            cur_packet:     0,
            streams:        Vec::new(),
            str_ids:        Vec::new(),
            queued_pkts:    Vec::new(),
            slice_buf:      Vec::new(),
        }
    }
#[allow(unused_variables)]
    fn read_header(&mut self, strmgr: &mut StreamManager) -> DemuxerResult<()> {
        let (id, size, ver) = read_chunk(self.src)?;
        validate!(id == mktag!(b".RMF"));
        validate!(size >= RMVB_HDR_SIZE);
        let fver    = self.src.read_u32be()?;
        validate!(fver <= 1);
        let num_hdr = self.src.read_u32be()? as usize;
        validate!(num_hdr >= 1);
        if size > RMVB_HDR_SIZE {
            self.src.read_skip((size - RMVB_HDR_SIZE) as usize)?;
        }

        let (id, size, ver) = read_chunk(self.src)?;
        validate!(size >= RMVB_PROP_SIZE);
        validate!(ver == 0);
        let maxbr       = self.src.read_u32be()?;
        let avgbr       = self.src.read_u32be()?;
        let maxps       = self.src.read_u32be()?;
        let avgps       = self.src.read_u32be()?;
        let num_pkt     = self.src.read_u32be()? as usize;
        let duration    = self.src.read_u32be()?;
        let preroll     = self.src.read_u32be()?;
        let idx_off     = self.src.read_u32be()?;
        let data_off    = self.src.read_u32be()?;
        let num_streams = self.src.read_u16be()? as usize;
        let flags       = self.src.read_u16be()?;
        if size > RMVB_PROP_SIZE {
            self.src.read_skip((size - RMVB_PROP_SIZE) as usize)?;
        }

        for _ in 0..num_hdr {
            self.parse_chunk(strmgr)?;
        }
println!("now @ {:X} / {}", self.src.tell(), self.data_pos);
        validate!(self.data_pos > 0);
        self.src.seek(SeekFrom::Start(self.data_pos))?;
        let num_packets     = self.src.read_u32be()?;
        let next_data_hdr   = self.src.read_u32be()?;
        self.num_packets = num_packets;
        self.cur_packet  = 0;
        Ok(())
    }
    fn parse_chunk(&mut self, strmgr: &mut StreamManager) -> DemuxerResult<()> {
        let (id, size, ver) = read_chunk(self.src)?;
        let end_pos = self.src.tell() - 10 + (size as u64);

        validate!(ver == 0);
             if id == mktag!(b"CONT") { self.parse_content_desc()?; }
        else if id == mktag!(b"MDPR") { self.parse_mdpr(strmgr)?; }
        else if id == mktag!(b"DATA") { if self.data_pos == 0 { self.data_pos = self.src.tell(); } }
        else if id == mktag!(b"INDX") { /* do nothing for now */ }
        else                          { println!("unknown chunk type {:08X}", id); }

        let cpos = self.src.tell();
        if cpos < end_pos {
            self.src.read_skip((end_pos - cpos) as usize)?;
        }
        Ok(())
    }
#[allow(unused_variables)]
    fn parse_content_desc(&mut self) -> DemuxerResult<()> {
        let title_len       = self.src.read_u16be()? as usize;
        self.src.read_skip(title_len)?;
        let author_len      = self.src.read_u16be()? as usize;
        self.src.read_skip(author_len)?;
        let copywrong_len   = self.src.read_u16be()? as usize;
        self.src.read_skip(copywrong_len)?;
        let comment_len     = self.src.read_u16be()? as usize;
        self.src.read_skip(comment_len)?;
        Ok(())
    }
#[allow(unused_variables)]
    fn parse_mdpr(&mut self, strmgr: &mut StreamManager) -> DemuxerResult<()> {
        let stream_no       = self.src.read_u16be()?;
//todo check stream_no for duplicates
        let maxbr           = self.src.read_u32be()?;
        let avgbr           = self.src.read_u32be()?;
        let maxps           = self.src.read_u32be()?;
        let avgps           = self.src.read_u32be()?;
        let start           = self.src.read_u32be()?;
        let preroll         = self.src.read_u32be()?;
        let duration        = self.src.read_u32be()?;
        let sname_size      = self.src.read_byte()? as usize;
        let sname           = read_string_size(self.src, sname_size)?;
println!("str #{} sname = {} pkts {}/{} start {} preroll {}", stream_no, sname, maxps, avgps, start, preroll);
        let mime_size       = self.src.read_byte()? as usize;
        let mime            = read_string_size(self.src, mime_size)?;
println!("mime = {}", mime);
        let edata_size      = self.src.read_u32be()? as usize;
        let edata: Option<Vec<u8>> = if edata_size == 0 { None } else {
            let mut edvec: Vec<u8> = Vec::with_capacity(edata_size);
            edvec.resize(edata_size, 0);
            self.src.read_buf(&mut edvec)?;
            Some(edvec)
        };
        self.str_ids.push(stream_no);
        if edata_size > 8 {
            if let Some(edata_) = edata {
                let mut mr = MemoryReader::new_read(edata_.as_slice());
                let mut src = ByteReader::new(&mut mr);

                let tag  = src.read_u32be()?;
                let tag2 = src.peek_u32be()?;
println!("tag1 {:X} tag2 {:X}", tag, tag2);
                if tag == mktag!('.', 'r', 'a', 0xFD) {
                    //todo audio
                    let cname = "unknown";//find_codec_name(RM_AUDIO_CODEC_REGISTER, fcc);
                    let soniton = NASoniton::new(16, SONITON_FLAG_SIGNED);
                    let ahdr = NAAudioInfo::new(44100, 2, soniton, 1/*block_align as usize*/);
                    let extradata = None;
                    let ainfo = NACodecInfo::new(cname, NACodecTypeInfo::Audio(ahdr), extradata);
                    let res = strmgr.add_stream(NAStream::new(StreamType::Audio, stream_no as u32, ainfo, 1, 44100));
                    if res.is_none() { return Err(MemoryError); }

                    let astr = RMAudioStream::new(Deinterleaver::None);
                    self.streams.push(RMStreamType::Audio(astr));
                } else if ((tag2 == mktag!('V', 'I', 'D', 'O')) || (tag2 == mktag!('I', 'M', 'A', 'G'))) && ((tag as usize) <= edata_size) {
                    src.read_skip(4)?;
                    let fcc         = src.read_u32be()?;
                    let width       = src.read_u16be()? as usize;
                    let height      = src.read_u16be()? as usize;
                    let bpp         = src.read_u16be()?;
                    let pad_w       = src.read_u16be()?;
                    let pad_h       = src.read_u16be()?;
                    let fps;
                    if tag2 == mktag!('V', 'I', 'D', 'O') {
                        fps         = src.read_u32be()?;
                    } else {
                        fps = 0x10000;
                    }
                    let extradata: Option<Vec<u8>>;
                    if src.left() > 0 {
                        let eslice = &edata_[(src.tell() as usize)..];
                        extradata = Some(eslice.to_vec());
                    } else {
                        extradata = None;
                    }
                    let cname = find_codec_name(RM_VIDEO_CODEC_REGISTER, fcc);

                    let vhdr = NAVideoInfo::new(width, height, false, RGB24_FORMAT);
                    let vinfo = NACodecInfo::new(cname, NACodecTypeInfo::Video(vhdr), extradata);
                    let res = strmgr.add_stream(NAStream::new(StreamType::Video, stream_no as u32, vinfo, 0x10000, fps));
                    if res.is_none() { return Err(DemuxerError::MemoryError); }

                    let vstr = RMVideoStream::new();
                    self.streams.push(RMStreamType::Video(vstr));
                } else {
                    self.streams.push(RMStreamType::Logical);
                }
            }
        } else {
            self.streams.push(RMStreamType::Unknown);
        }

        Ok(())
    }
/*#[allow(unused_variables)]
    fn read_pkt_header(&mut self) -> DemuxerResult<()> {
        let ver             = self.src.read_u16be()?;
        validate!(ver <= 1);
        let str_no          = self.src.read_u16be()?;
        let timestamp       = self.src.read_u32be()?;
        if ver == 0 {
            let pkt_group   = self.src.read_byte()?;
            let pkt_flags   = self.src.read_byte()?;
        } else {
            let asm_rule    = self.src.read_u16be()?;
            let asm_flags   = self.src.read_byte()?;
        }
        Ok(())
    }*/
}

fn read_string(src: &mut ByteReader) -> DemuxerResult<String> {
    let mut vec: Vec<u8> = Vec::new();
    loop {
        let c = src.read_byte()?;
        if c == 0 { break; }
        vec.push(c);
    }
    let str = String::from_utf8(vec);
    if str.is_ok() {
        Ok(str.unwrap())
    } else {
        Ok(String::new())
    }
}

fn read_string_size(src: &mut ByteReader, size: usize) -> DemuxerResult<String> {
    let mut vec: Vec<u8> = Vec::new();
    for _ in 0..size {
        let c = src.read_byte()?;
        vec.push(c);
    }
    let str = String::from_utf8(vec);
    if str.is_ok() {
        Ok(str.unwrap())
    } else {
        Ok(String::new())
    }
}

#[allow(dead_code)]
#[allow(unused_variables)]
fn parse_rm_stream(io: &mut ByteReader) -> DemuxerResult<NAStream> {
    let mimetype    = read_string(io)?;
    let strname     = read_string(io)?;
    let strnum      = io.read_u32le()?;
    let maxbr       = io.read_u32le()?;
    let avgbr       = io.read_u32le()?;
    let maxsize     = io.read_u32le()?;
    let avgsize     = io.read_u32le()?;
    let duration    = io.read_u32le()?;
    let preroll     = io.read_u32le()?;
    let start       = io.read_u32le()?;
    let edatalen    = io.read_u32le()? as usize;
    let mut edata: Vec<u8> = Vec::with_capacity(edatalen);
    edata.resize(edatalen, 0);
    io.read_buf(&mut edata)?;
    let numprops    = io.read_u32le()? as usize;
    //read properties
    unimplemented!();
}

#[allow(dead_code)]
#[allow(unused_variables)]
fn read_ra_vbr_stream(io: &mut ByteReader) -> DemuxerResult<NAPacket> {
    let hdrsizesize = io.read_u16le()?;
    let num_entries = (hdrsizesize / 16) as usize;
    let mut sizes: Vec<usize> = Vec::with_capacity(num_entries);
    for _ in 0..num_entries {
        let sz      = io.read_u16le()? as usize;
        sizes.push(sz);
    }
    for i in 0..num_entries {
//read packet of sizes[i]
    }
    unimplemented!();
}

//todo interleavers

//todo opaque data


static RM_VIDEO_CODEC_REGISTER: &'static [(&[u8;4], &str)] = &[
    (b"RV10", "realvideo1"),
    (b"RV20", "realvideo2"),
    (b"RVTR", "realvideo2"),
    (b"RV30", "realvideo3"),
    (b"RV40", "realvideo4"),
    (b"CLV1", "clearvideo"),
];

static RM_AUDIO_CODEC_REGISTER: &'static [(&[u8;4], &str)] = &[
    (b"lpcJ", "ra14.4"),
    (b"28_8", "ra28.8"),
    (b"cook", "cook"),
    (b"dnet", "ac3"),
    (b"sipr", "sipro"),
    (b"atrc", "atrac3"),
    (b"LSD:", "ralf"),
    (b"raac", "aac"),
    (b"racp", "aac"),
];

pub struct RealMediaDemuxerCreator { }

impl DemuxerCreator for RealMediaDemuxerCreator {
    fn new_demuxer<'a>(&self, br: &'a mut ByteReader<'a>) -> Box<DemuxCore<'a> + 'a> {
        Box::new(RealMediaDemuxer::new(br))
    }
    fn get_name(&self) -> &'static str { "realmedia" }
}

#[cfg(test)]
mod test {
    use super::*;
    use std::fs::File;

    #[test]
    fn test_rm_demux() {
        let mut file =
            File::open("assets/RV/rv10_dnet_640x352_realvideo_encoder_4.0.rm").unwrap();
//            File::open("assets/RV/rv20_cook_640x352_realproducer_plus_8.51.rm").unwrap();
//            File::open("assets/RV/rv20_svt_atrc_640x352_realproducer_plus_8.51.rm").unwrap();
//            File::open("assets/RV/rv30_atrc_384x208_realproducer_plus_8.51.rm").unwrap();
//            File::open("assets/RV/rv30_chroma_drift.rm").unwrap();
//            File::open("assets/RV/rv30_weighted_mc.rm").unwrap();
//            File::open("assets/RV/rv40_weighted_mc.rmvb").unwrap();
//            File::open("assets/RV/rv40_weighted_mc_2.rmvb").unwrap();
//            File::open("assets/RV/clv1_sipr_384x208_realvideo_encoder_4.0.rm").unwrap();
//            File::open("assets/RV/luckynight.rmvb").unwrap();
//            File::open("assets/RV/rv40_ralf.rmvb").unwrap();
        let mut fr = FileReader::new_read(&mut file);
        let mut br = ByteReader::new(&mut fr);
        let mut dmx = RealMediaDemuxer::new(&mut br);
        let mut sm = StreamManager::new();
        dmx.open(&mut sm).unwrap();

        loop {
            let pktres = dmx.get_frame(&mut sm);
            if let Err(e) = pktres {
                if e == DemuxerError::EOF { break; }
                panic!("error");
            }
            let pkt = pktres.unwrap();
            println!("Got {}", pkt);
        }
panic!("the end");
    }
}
Commit	Line	Data
ce52b3b5 KS	1	use super::*;
	2	use super::DemuxerError::*;
	3	//use io::byteio::*;
	4	//use frame::*;
	5	use formats::*;
	6	use std::io::SeekFrom;
	7	use std::mem;
	8
	9	macro_rules! mktag {
	10	($a:expr, $b:expr, $c:expr, $d:expr) => ({
	11	(($a as u32) << 24) \| (($b as u32) << 16) \| (($c as u32) << 8) \| ($d as u32)
	12	});
	13	($arr:expr) => ({
	14	(($arr[0] as u32) << 24) \| (($arr[1] as u32) << 16) \| (($arr[2] as u32) << 8) \| ($arr[3] as u32)
	15	});
	16	}
	17
	18	struct RMVideoStream {
	19	frame: Vec<u8>,
	20	hdr_size: usize,
	21	frame_size: usize,
	22	frame_pos: usize,
	23	}
	24
	25	impl RMVideoStream {
	26	fn new() -> Self {
	27	RMVideoStream {
	28	frame: Vec::new(),
	29	hdr_size: 0,
	30	frame_size: 0,
	31	frame_pos: 0,
	32	}
	33	}
	34	fn flush(&mut self) {
	35	self.frame.truncate(0);
	36	self.frame_size = 0;
	37	self.frame_pos = 0;
	38	}
	39	fn start_slice(&mut self, num_slices: usize, frame_size: usize, data: &[u8]) {
	40	self.hdr_size = num_slices * 8 + 1;
	41	self.frame.resize(frame_size + self.hdr_size, 0);
	42	self.frame[0] = (num_slices - 1) as u8;
	43	self.frame_pos = 0;
	44	self.add_slice(1, data);
	45	}
	46	fn add_slice(&mut self, slice_no: usize, data: &[u8]) {
	47	self.write_slice_info(slice_no);
	48	let mut dslice = &mut self.frame[self.hdr_size + self.frame_pos..][..data.len()];
	49	dslice.copy_from_slice(data);
	50	self.frame_pos += data.len();
	51	}
	52	fn write_slice_info(&mut self, slice_no: usize) {
	53	let off = 1 + (slice_no - 1) * 8;
	54	self.frame[off + 0] = 0;
	55	self.frame[off + 1] = 0;
	56	self.frame[off + 2] = 0;
	57	self.frame[off + 3] = 1;
	58	self.frame[off + 4] = (self.frame_pos >> 24) as u8;
	59	self.frame[off + 5] = (self.frame_pos >> 16) as u8;
	60	self.frame[off + 6] = (self.frame_pos >> 8) as u8;
	61	self.frame[off + 7] = (self.frame_pos >> 0) as u8;
	62	}
	63	fn get_frame_data(&mut self) -> Vec<u8> {
	64	let mut v: Vec<u8> = Vec::new();
65	mem::swap(&mut v, &mut self.frame);
66	self.flush();
67	v
68	}
69	}
70
71	#[derive(Clone,Copy,PartialEq)]
72	enum Deinterleaver {
73	None,
74	Generic,
75	Sipro,
76	VBR,
77	}
78
79	struct RMAudioStream {
80	deint: Deinterleaver,
81	}
82
83	impl RMAudioStream {
84	fn new(deint: Deinterleaver) -> Self {
85	RMAudioStream { deint: deint }
86	}
87	}
88
89	enum RMStreamType {
90	Audio(RMAudioStream),
91	Video(RMVideoStream),
92	Logical,
93	Unknown,
94	}
95
96	struct RealMediaDemuxer<'a> {
97	src: &'a mut ByteReader<'a>,
98	data_pos: u64,
99	num_packets: u32,
100	cur_packet: u32,
101
102	streams: Vec<RMStreamType>,
103	str_ids: Vec<u16>,
104
105	queued_pkts: Vec<NAPacket>,
106	slice_buf: Vec<u8>,
107	}
108
109	fn find_codec_name(registry: &[(&[u8;4], &'static str)], fcc: u32) -> &'static str {
110	for &(fourcc, name) in registry {
111	if mktag!(fourcc) == fcc { return name; }
112	}
113	"unknown"
114	}
115
116	fn read_14or30(src: &mut ByteReader) -> DemuxerResult<(bool, u32)> {
117	let tmp = src.read_u16be()?;
118	let flag = (tmp & 0x8000) != 0;
119	if (tmp & 0x4000) == 0x4000 {
120	Ok((flag, ((tmp & 0x3FFF) as u32)))
121	} else {
122	let val = ((tmp as u32) << 16) \| (src.read_u16be()? as u32);
123	Ok((flag, val & 0x3FFFFFFF))
124	}
125	}
126
127	fn read_video_buf(src: &mut ByteReader, stream: Rc<NAStream>, ts: u32, keyframe: bool, frame_size: usize) -> DemuxerResult<NAPacket> {
128	let size = (frame_size as usize) + 9;
129	let mut vec: Vec<u8> = Vec::with_capacity(size);
130	vec.resize(size, 0);
131	//v[0] = 0; // 1 slice
132	vec[4] = 1;
133	src.read_buf(&mut vec[9..])?;
134
135	let (tb_num, tb_den) = stream.get_timebase();
136	let ts = NATimeInfo::new(Some(ts as u64), None, None, tb_num, tb_den);
137	Ok(NAPacket::new(stream, ts, keyframe, vec))
138	}
139
140	fn read_multiple_frame(src: &mut ByteReader, stream: Rc<NAStream>, keyframe: bool, skip_mtype: bool) -> DemuxerResult<NAPacket> {
141	if !skip_mtype {
142	let mtype = src.read_byte()?;
143	validate!(mtype == 0xC0);
144	}
145	let (_, frame_size) = read_14or30(src)?;
146	let (_, timestamp) = read_14or30(src)?;
147	let seq_no = src.read_byte()?;
148	println!(" multiple frame size {} ts {} seq {}", frame_size, timestamp, seq_no);
149
150	read_video_buf(src, stream, timestamp, keyframe, frame_size as usize)
151	}
152
153	impl<'a> DemuxCore<'a> for RealMediaDemuxer<'a> {
154	#[allow(unused_variables)]
155	fn open(&mut self, strmgr: &mut StreamManager) -> DemuxerResult<()> {
156	self.read_header(strmgr)?;
157	Ok(())
158	}
159
160	#[allow(unused_variables)]
161	fn get_frame(&mut self, strmgr: &mut StreamManager) -> DemuxerResult<NAPacket> {
162	if !self.queued_pkts.is_empty() {
163	let pkt = self.queued_pkts.pop().unwrap();
164	return Ok(pkt);
165	}
166	loop {
167	if self.cur_packet >= self.num_packets { return Err(DemuxerError::EOF); }
168
169	let pkt_start = self.src.tell();
170	let ver = self.src.read_u16le()?;
171	validate!(ver <= 1);
172	let len = self.src.read_u16be()? as usize;
173	let str_no = self.src.read_u16be()?;
174	let ts = self.src.read_u32be()?;
175	let pkt_grp;
176	if ver == 0 {
177	pkt_grp = self.src.read_byte()?;
178	} else {
179	//asm_rule = self.src.read_u16le()?;
180	self.src.read_skip(2)?;
181	pkt_grp = 0;
182	}
183	let flags = self.src.read_byte()?;
184	let hdr_size = self.src.tell() - pkt_start;
185	println!("packet @{:X} size {} for {} ts {} grp {} flags {:X}", pkt_start, len, str_no, ts, pkt_grp, flags);
186	self.cur_packet += 1;
187
188	let payload_size = len - (hdr_size as usize);
189
190	let sr = self.str_ids.iter().position(\|x\| *x == str_no);
191	if sr.is_none() {
192	println!("stream {} not found", str_no);
193	self.src.read_skip(payload_size)?;
194	return Err(DemuxerError::InvalidData);
195	}
196	let str_id = sr.unwrap();
197	let stream = strmgr.get_stream_by_id(str_no as u32).unwrap();
198	println!(" stream {}", str_id);
199	if strmgr.is_ignored_id(str_no as u32) {
200	self.src.read_skip(payload_size)?;
201	continue;
202	}
203	//todo skip unwanted packet
204	let keyframe = (flags & KEYFRAME_FLAG) != 0;
205
206	let result = match self.streams[str_id] {
207	RMStreamType::Video(ref mut vstr) => {
208
209	let pos = self.src.tell();
210	let b0 = self.src.read_byte()?;
211	match b0 >> 6 {
212	0 => { // partial frame
213	let b1 = self.src.read_byte()?;
214	let hdr1 = ((b0 as u16) << 8) \| (b1 as u16);
215	let num_pkts = ((hdr1 >> 7) & 0x7F) as usize;
216	let packet_num = hdr1 & 0x7F;
217	let (_, frame_size) = read_14or30(self.src)?;
218	let (_, off) = read_14or30(self.src)?;
219	let seq_no = self.src.read_byte()?;
220	println!(" mode 0 pkt {}/{} off {}/{} seq {}", packet_num, num_pkts, off, frame_size, seq_no);
221	let hdr_skip = (self.src.tell() - pos) as usize;
222
223	let slice_size = (payload_size - hdr_skip) as usize;
224	self.slice_buf.resize(slice_size, 0);
225	self.src.read_buf(self.slice_buf.as_mut_slice())?;
226	if packet_num == 1 {
227	vstr.start_slice(num_pkts, frame_size as usize, self.slice_buf.as_slice());
228	} else {
229	vstr.add_slice(packet_num as usize, self.slice_buf.as_slice());
230	}
231	continue;
232	},
233	1 => { // whole frame
234	let seq_no = self.src.read_byte()?;
235	println!(" mode 1 seq {}", seq_no);
236	read_video_buf(self.src, stream, ts, keyframe, payload_size - 1)
237	},
238	2 => { // last partial frame
239	let b1 = self.src.read_byte()?;
240	let hdr1 = ((b0 as u16) << 8) \| (b1 as u16);
241	let num_pkts = ((hdr1 >> 7) & 0x7F) as usize;
242	let packet_num = hdr1 & 0x7F;
243	let (_, frame_size) = read_14or30(self.src)?;
244	let (_, tail_size) = read_14or30(self.src)?;
245	let seq_no = self.src.read_byte()?;
246	println!(" mode 2 pkt {}/{} tail {}/{} seq {}", packet_num, num_pkts, tail_size, frame_size, seq_no);
247	self.slice_buf.resize(tail_size as usize, 0);
248	self.src.read_buf(self.slice_buf.as_mut_slice())?;
249	vstr.add_slice(packet_num as usize, self.slice_buf.as_slice());
250
251	while self.src.tell() < pos + (payload_size as u64) {
252	let res = read_multiple_frame(self.src, stream.clone(), false, false);
253	if res.is_err() { break; }
254	self.queued_pkts.push(res.unwrap());
255	}
256	self.queued_pkts.reverse();
257	let (tb_num, tb_den) = stream.get_timebase();
258	let ts = NATimeInfo::new(Some(ts as u64), None, None, tb_num, tb_den);
259	let pkt = NAPacket::new(stream, ts, keyframe, vstr.get_frame_data());
260	Ok(pkt)
261	},
262	_ => { // multiple frames
263	println!(" mode 3");
264	let res = read_multiple_frame(self.src, stream.clone(), keyframe, true);
265	if res.is_err() { return res; }
266	while self.src.tell() < pos + (payload_size as u64) {
267	let res = read_multiple_frame(self.src, stream.clone(), false, false);
268	if res.is_err() { break; }
269	self.queued_pkts.push(res.unwrap());
270	}
271	self.queued_pkts.reverse();
272	res
273	},
274	}
275	},
276	RMStreamType::Audio(ref mut astr) => {
277	let (tb_num, tb_den) = stream.get_timebase();
278	let ts = NATimeInfo::new(Some(ts as u64), None, None, tb_num, tb_den);
279	self.src.read_packet(stream, ts, keyframe, payload_size)
280	},
281	_ => {
282	// self.src.read_skip(payload_size)?;
283	Err(DemuxerError::InvalidData)
284	},
285	};
286	return result;
287	}
288	}
289
290	#[allow(unused_variables)]
291	fn seek(&mut self, time: u64) -> DemuxerResult<()> {
292	Err(NotImplemented)
293	}
294	}
295
296	fn read_chunk(src: &mut ByteReader) -> DemuxerResult<(u32, u32, u16)> {
297	let id = src.read_u32be()?;
298	let size = src.read_u32be()?;
299	validate!(size >= 10);
300	let ver = src.read_u16be()?;
301	validate!(ver <= 1);
302	Ok((id, size, ver))
303	}
304
305	const RMVB_HDR_SIZE: u32 = 18;
306	const RMVB_PROP_SIZE: u32 = 50;
307	const KEYFRAME_FLAG: u8 = 0x02;
308
309	impl<'a> RealMediaDemuxer<'a> {
310	fn new(io: &'a mut ByteReader<'a>) -> Self {
311	RealMediaDemuxer {
312	src: io,
313	data_pos: 0,
314	num_packets: 0,
315	cur_packet: 0,
316	streams: Vec::new(),
317	str_ids: Vec::new(),
318	queued_pkts: Vec::new(),
319	slice_buf: Vec::new(),
320	}
321	}
322	#[allow(unused_variables)]
323	fn read_header(&mut self, strmgr: &mut StreamManager) -> DemuxerResult<()> {
324	let (id, size, ver) = read_chunk(self.src)?;
325	validate!(id == mktag!(b".RMF"));
326	validate!(size >= RMVB_HDR_SIZE);
327	let fver = self.src.read_u32be()?;
328	validate!(fver <= 1);
329	let num_hdr = self.src.read_u32be()? as usize;
330	validate!(num_hdr >= 1);
331	if size > RMVB_HDR_SIZE {
332	self.src.read_skip((size - RMVB_HDR_SIZE) as usize)?;
333	}
334
335	let (id, size, ver) = read_chunk(self.src)?;
336	validate!(size >= RMVB_PROP_SIZE);
337	validate!(ver == 0);
338	let maxbr = self.src.read_u32be()?;
339	let avgbr = self.src.read_u32be()?;
340	let maxps = self.src.read_u32be()?;
341	let avgps = self.src.read_u32be()?;
342	let num_pkt = self.src.read_u32be()? as usize;
343	let duration = self.src.read_u32be()?;
344	let preroll = self.src.read_u32be()?;
345	let idx_off = self.src.read_u32be()?;
346	let data_off = self.src.read_u32be()?;
347	let num_streams = self.src.read_u16be()? as usize;
348	let flags = self.src.read_u16be()?;
349	if size > RMVB_PROP_SIZE {
350	self.src.read_skip((size - RMVB_PROP_SIZE) as usize)?;
351	}
352
353	for _ in 0..num_hdr {
354	self.parse_chunk(strmgr)?;
355	}
356	println!("now @ {:X} / {}", self.src.tell(), self.data_pos);
357	validate!(self.data_pos > 0);
358	self.src.seek(SeekFrom::Start(self.data_pos))?;
359	let num_packets = self.src.read_u32be()?;
360	let next_data_hdr = self.src.read_u32be()?;
361	self.num_packets = num_packets;
362	self.cur_packet = 0;
363	Ok(())
364	}
365	fn parse_chunk(&mut self, strmgr: &mut StreamManager) -> DemuxerResult<()> {
366	let (id, size, ver) = read_chunk(self.src)?;
367	let end_pos = self.src.tell() - 10 + (size as u64);
368
369	validate!(ver == 0);
370	if id == mktag!(b"CONT") { self.parse_content_desc()?; }
371	else if id == mktag!(b"MDPR") { self.parse_mdpr(strmgr)?; }
372	else if id == mktag!(b"DATA") { if self.data_pos == 0 { self.data_pos = self.src.tell(); } }
373	else if id == mktag!(b"INDX") { /* do nothing for now */ }
374	else { println!("unknown chunk type {:08X}", id); }
375
376	let cpos = self.src.tell();
377	if cpos < end_pos {
378	self.src.read_skip((end_pos - cpos) as usize)?;
379	}
380	Ok(())
381	}
382	#[allow(unused_variables)]
383	fn parse_content_desc(&mut self) -> DemuxerResult<()> {
384	let title_len = self.src.read_u16be()? as usize;
385	self.src.read_skip(title_len)?;
386	let author_len = self.src.read_u16be()? as usize;
387	self.src.read_skip(author_len)?;
388	let copywrong_len = self.src.read_u16be()? as usize;
389	self.src.read_skip(copywrong_len)?;
390	let comment_len = self.src.read_u16be()? as usize;
391	self.src.read_skip(comment_len)?;
392	Ok(())
393	}
394	#[allow(unused_variables)]
395	fn parse_mdpr(&mut self, strmgr: &mut StreamManager) -> DemuxerResult<()> {
396	let stream_no = self.src.read_u16be()?;
397	//todo check stream_no for duplicates
398	let maxbr = self.src.read_u32be()?;
399	let avgbr = self.src.read_u32be()?;
400	let maxps = self.src.read_u32be()?;
401	let avgps = self.src.read_u32be()?;
402	let start = self.src.read_u32be()?;
403	let preroll = self.src.read_u32be()?;
404	let duration = self.src.read_u32be()?;
405	let sname_size = self.src.read_byte()? as usize;
406	let sname = read_string_size(self.src, sname_size)?;
407	println!("str #{} sname = {} pkts {}/{} start {} preroll {}", stream_no, sname, maxps, avgps, start, preroll);
408	let mime_size = self.src.read_byte()? as usize;
409	let mime = read_string_size(self.src, mime_size)?;
410	println!("mime = {}", mime);
411	let edata_size = self.src.read_u32be()? as usize;
412	let edata: Option<Vec<u8>> = if edata_size == 0 { None } else {
413	let mut edvec: Vec<u8> = Vec::with_capacity(edata_size);
414	edvec.resize(edata_size, 0);
415	self.src.read_buf(&mut edvec)?;
416	Some(edvec)
417	};
418	self.str_ids.push(stream_no);
419	if edata_size > 8 {
420	if let Some(edata_) = edata {
421	let mut mr = MemoryReader::new_read(edata_.as_slice());
422	let mut src = ByteReader::new(&mut mr);
423
424	let tag = src.read_u32be()?;
425	let tag2 = src.peek_u32be()?;
426	println!("tag1 {:X} tag2 {:X}", tag, tag2);
427	if tag == mktag!('.', 'r', 'a', 0xFD) {
428	//todo audio
429	let cname = "unknown";//find_codec_name(RM_AUDIO_CODEC_REGISTER, fcc);
430	let soniton = NASoniton::new(16, SONITON_FLAG_SIGNED);
431	let ahdr = NAAudioInfo::new(44100, 2, soniton, 1/block_align as usize/);
432	let extradata = None;
433	let ainfo = NACodecInfo::new(cname, NACodecTypeInfo::Audio(ahdr), extradata);
434	let res = strmgr.add_stream(NAStream::new(StreamType::Audio, stream_no as u32, ainfo, 1, 44100));
435	if res.is_none() { return Err(MemoryError); }
436
437	let astr = RMAudioStream::new(Deinterleaver::None);
438	self.streams.push(RMStreamType::Audio(astr));
439	} else if ((tag2 == mktag!('V', 'I', 'D', 'O')) \|\| (tag2 == mktag!('I', 'M', 'A', 'G'))) && ((tag as usize) <= edata_size) {
440	src.read_skip(4)?;
441	let fcc = src.read_u32be()?;
442	let width = src.read_u16be()? as usize;
443	let height = src.read_u16be()? as usize;
444	let bpp = src.read_u16be()?;
445	let pad_w = src.read_u16be()?;
446	let pad_h = src.read_u16be()?;
447	let fps;
448	if tag2 == mktag!('V', 'I', 'D', 'O') {
449	fps = src.read_u32be()?;
450	} else {
451	fps = 0x10000;
452	}
453	let extradata: Option<Vec<u8>>;
454	if src.left() > 0 {
455	let eslice = &edata_[(src.tell() as usize)..];
456	extradata = Some(eslice.to_vec());
457	} else {
458	extradata = None;
459	}
460	let cname = find_codec_name(RM_VIDEO_CODEC_REGISTER, fcc);
461
462	let vhdr = NAVideoInfo::new(width, height, false, RGB24_FORMAT);
463	let vinfo = NACodecInfo::new(cname, NACodecTypeInfo::Video(vhdr), extradata);
464	let res = strmgr.add_stream(NAStream::new(StreamType::Video, stream_no as u32, vinfo, 0x10000, fps));
465	if res.is_none() { return Err(DemuxerError::MemoryError); }
466
467	let vstr = RMVideoStream::new();
468	self.streams.push(RMStreamType::Video(vstr));
469	} else {
470	self.streams.push(RMStreamType::Logical);
471	}
472	}
473	} else {
474	self.streams.push(RMStreamType::Unknown);
475	}
476
477	Ok(())
478	}
479	/*#[allow(unused_variables)]
480	fn read_pkt_header(&mut self) -> DemuxerResult<()> {
481	let ver = self.src.read_u16be()?;
482	validate!(ver <= 1);
483	let str_no = self.src.read_u16be()?;
484	let timestamp = self.src.read_u32be()?;
485	if ver == 0 {
486	let pkt_group = self.src.read_byte()?;
487	let pkt_flags = self.src.read_byte()?;
488	} else {
489	let asm_rule = self.src.read_u16be()?;
490	let asm_flags = self.src.read_byte()?;
491	}
492	Ok(())
493	}*/
494	}
495
496	fn read_string(src: &mut ByteReader) -> DemuxerResult<String> {
497	let mut vec: Vec<u8> = Vec::new();
498	loop {
499	let c = src.read_byte()?;
500	if c == 0 { break; }
501	vec.push(c);
502	}
503	let str = String::from_utf8(vec);
504	if str.is_ok() {
505	Ok(str.unwrap())
506	} else {
507	Ok(String::new())
508	}
509	}
510
511	fn read_string_size(src: &mut ByteReader, size: usize) -> DemuxerResult<String> {
512	let mut vec: Vec<u8> = Vec::new();
513	for _ in 0..size {
514	let c = src.read_byte()?;
515	vec.push(c);
516	}
517	let str = String::from_utf8(vec);
518	if str.is_ok() {
519	Ok(str.unwrap())
520	} else {
521	Ok(String::new())
522	}
523	}
524
525	#[allow(dead_code)]
526	#[allow(unused_variables)]
527	fn parse_rm_stream(io: &mut ByteReader) -> DemuxerResult<NAStream> {
528	let mimetype = read_string(io)?;
529	let strname = read_string(io)?;
530	let strnum = io.read_u32le()?;
531	let maxbr = io.read_u32le()?;
532	let avgbr = io.read_u32le()?;
533	let maxsize = io.read_u32le()?;
534	let avgsize = io.read_u32le()?;
535	let duration = io.read_u32le()?;
536	let preroll = io.read_u32le()?;
537	let start = io.read_u32le()?;
538	let edatalen = io.read_u32le()? as usize;
539	let mut edata: Vec<u8> = Vec::with_capacity(edatalen);
540	edata.resize(edatalen, 0);
541	io.read_buf(&mut edata)?;
542	let numprops = io.read_u32le()? as usize;
543	//read properties
544	unimplemented!();
545	}
546
547	#[allow(dead_code)]
548	#[allow(unused_variables)]
549	fn read_ra_vbr_stream(io: &mut ByteReader) -> DemuxerResult<NAPacket> {
550	let hdrsizesize = io.read_u16le()?;
551	let num_entries = (hdrsizesize / 16) as usize;
552	let mut sizes: Vec<usize> = Vec::with_capacity(num_entries);
553	for _ in 0..num_entries {
554	let sz = io.read_u16le()? as usize;
555	sizes.push(sz);
556	}
557	for i in 0..num_entries {
558	//read packet of sizes[i]
559	}
560	unimplemented!();
561	}
562
563	//todo interleavers
564
565	//todo opaque data
566
567
568	static RM_VIDEO_CODEC_REGISTER: &'static [(&[u8;4], &str)] = &[
569	(b"RV10", "realvideo1"),
570	(b"RV20", "realvideo2"),
571	(b"RVTR", "realvideo2"),
572	(b"RV30", "realvideo3"),
573	(b"RV40", "realvideo4"),
574	(b"CLV1", "clearvideo"),
575	];
576
577	static RM_AUDIO_CODEC_REGISTER: &'static [(&[u8;4], &str)] = &[
578	(b"lpcJ", "ra14.4"),
579	(b"28_8", "ra28.8"),
580	(b"cook", "cook"),
581	(b"dnet", "ac3"),
582	(b"sipr", "sipro"),
583	(b"atrc", "atrac3"),
584	(b"LSD:", "ralf"),
585	(b"raac", "aac"),
586	(b"racp", "aac"),
587	];
588
589	pub struct RealMediaDemuxerCreator { }
590
591	impl DemuxerCreator for RealMediaDemuxerCreator {
592	fn new_demuxer<'a>(&self, br: &'a mut ByteReader<'a>) -> Box<DemuxCore<'a> + 'a> {
593	Box::new(RealMediaDemuxer::new(br))
594	}
595	fn get_name(&self) -> &'static str { "realmedia" }
596	}
597
598	#[cfg(test)]
599	mod test {
600	use super::*;
601	use std::fs::File;
602
603	#[test]
604	fn test_rm_demux() {
605	let mut file =
606	File::open("assets/RV/rv10_dnet_640x352_realvideo_encoder_4.0.rm").unwrap();
607	// File::open("assets/RV/rv20_cook_640x352_realproducer_plus_8.51.rm").unwrap();
608	// File::open("assets/RV/rv20_svt_atrc_640x352_realproducer_plus_8.51.rm").unwrap();
609	// File::open("assets/RV/rv30_atrc_384x208_realproducer_plus_8.51.rm").unwrap();
610	// File::open("assets/RV/rv30_chroma_drift.rm").unwrap();
611	// File::open("assets/RV/rv30_weighted_mc.rm").unwrap();
612	// File::open("assets/RV/rv40_weighted_mc.rmvb").unwrap();
613	// File::open("assets/RV/rv40_weighted_mc_2.rmvb").unwrap();
614	// File::open("assets/RV/clv1_sipr_384x208_realvideo_encoder_4.0.rm").unwrap();
615	// File::open("assets/RV/luckynight.rmvb").unwrap();
616	// File::open("assets/RV/rv40_ralf.rmvb").unwrap();
617	let mut fr = FileReader::new_read(&mut file);
618	let mut br = ByteReader::new(&mut fr);
619	let mut dmx = RealMediaDemuxer::new(&mut br);
620	let mut sm = StreamManager::new();
621	dmx.open(&mut sm).unwrap();
622
623	loop {
624	let pktres = dmx.get_frame(&mut sm);
625	if let Err(e) = pktres {
626	if e == DemuxerError::EOF { break; }
627	panic!("error");
628	}
629	let pkt = pktres.unwrap();
630	println!("Got {}", pkt);
631	}
632	panic!("the end");
633	}
634	}