[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 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
    }
}

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

#[allow(dead_code)]
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()?;
if id == 0 { return Ok((0, 0, 0)); }
    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 {
            let last = self.parse_chunk(strmgr)?;
            if last { break; }
        }
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<bool> {
        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 if id == 0               { return Ok(true); }
        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(false)
    }
#[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_rm"),
];

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