[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()?;
    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"),
];

#[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()?;
300	let size = src.read_u32be()?;
301	validate!(size >= 10);
302	let ver = src.read_u16be()?;
303	validate!(ver <= 1);
304	Ok((id, size, ver))
305	}
306
307	const RMVB_HDR_SIZE: u32 = 18;
308	const RMVB_PROP_SIZE: u32 = 50;
309	const KEYFRAME_FLAG: u8 = 0x02;
310
311	impl<'a> RealMediaDemuxer<'a> {
312	fn new(io: &'a mut ByteReader<'a>) -> Self {
313	RealMediaDemuxer {
314	src: io,
315	data_pos: 0,
316	num_packets: 0,
317	cur_packet: 0,
318	streams: Vec::new(),
319	str_ids: Vec::new(),
320	queued_pkts: Vec::new(),
321	slice_buf: Vec::new(),
322	}
323	}
324	#[allow(unused_variables)]
325	fn read_header(&mut self, strmgr: &mut StreamManager) -> DemuxerResult<()> {
326	let (id, size, ver) = read_chunk(self.src)?;
327	validate!(id == mktag!(b".RMF"));
328	validate!(size >= RMVB_HDR_SIZE);
329	let fver = self.src.read_u32be()?;
330	validate!(fver <= 1);
331	let num_hdr = self.src.read_u32be()? as usize;
332	validate!(num_hdr >= 1);
333	if size > RMVB_HDR_SIZE {
334	self.src.read_skip((size - RMVB_HDR_SIZE) as usize)?;
335	}
336
337	let (id, size, ver) = read_chunk(self.src)?;
338	validate!(size >= RMVB_PROP_SIZE);
339	validate!(ver == 0);
340	let maxbr = self.src.read_u32be()?;
341	let avgbr = self.src.read_u32be()?;
342	let maxps = self.src.read_u32be()?;
343	let avgps = self.src.read_u32be()?;
344	let num_pkt = self.src.read_u32be()? as usize;
345	let duration = self.src.read_u32be()?;
346	let preroll = self.src.read_u32be()?;
347	let idx_off = self.src.read_u32be()?;
348	let data_off = self.src.read_u32be()?;
349	let num_streams = self.src.read_u16be()? as usize;
350	let flags = self.src.read_u16be()?;
351	if size > RMVB_PROP_SIZE {
352	self.src.read_skip((size - RMVB_PROP_SIZE) as usize)?;
353	}
354
355	for _ in 0..num_hdr {
356	self.parse_chunk(strmgr)?;
357	}
358	println!("now @ {:X} / {}", self.src.tell(), self.data_pos);
359	validate!(self.data_pos > 0);
360	self.src.seek(SeekFrom::Start(self.data_pos))?;
361	let num_packets = self.src.read_u32be()?;
362	let next_data_hdr = self.src.read_u32be()?;
363	self.num_packets = num_packets;
364	self.cur_packet = 0;
365	Ok(())
366	}
367	fn parse_chunk(&mut self, strmgr: &mut StreamManager) -> DemuxerResult<()> {
368	let (id, size, ver) = read_chunk(self.src)?;
369	let end_pos = self.src.tell() - 10 + (size as u64);
370
371	validate!(ver == 0);
372	if id == mktag!(b"CONT") { self.parse_content_desc()?; }
373	else if id == mktag!(b"MDPR") { self.parse_mdpr(strmgr)?; }
374	else if id == mktag!(b"DATA") { if self.data_pos == 0 { self.data_pos = self.src.tell(); } }
375	else if id == mktag!(b"INDX") { /* do nothing for now */ }
376	else { println!("unknown chunk type {:08X}", id); }
377
378	let cpos = self.src.tell();
379	if cpos < end_pos {
380	self.src.read_skip((end_pos - cpos) as usize)?;
381	}
382	Ok(())
383	}
384	#[allow(unused_variables)]
385	fn parse_content_desc(&mut self) -> DemuxerResult<()> {
386	let title_len = self.src.read_u16be()? as usize;
387	self.src.read_skip(title_len)?;
388	let author_len = self.src.read_u16be()? as usize;
389	self.src.read_skip(author_len)?;
390	let copywrong_len = self.src.read_u16be()? as usize;
391	self.src.read_skip(copywrong_len)?;
392	let comment_len = self.src.read_u16be()? as usize;
393	self.src.read_skip(comment_len)?;
394	Ok(())
395	}
396	#[allow(unused_variables)]
397	fn parse_mdpr(&mut self, strmgr: &mut StreamManager) -> DemuxerResult<()> {
398	let stream_no = self.src.read_u16be()?;
399	//todo check stream_no for duplicates
400	let maxbr = self.src.read_u32be()?;
401	let avgbr = self.src.read_u32be()?;
402	let maxps = self.src.read_u32be()?;
403	let avgps = self.src.read_u32be()?;
404	let start = self.src.read_u32be()?;
405	let preroll = self.src.read_u32be()?;
406	let duration = self.src.read_u32be()?;
407	let sname_size = self.src.read_byte()? as usize;
408	let sname = read_string_size(self.src, sname_size)?;
409	println!("str #{} sname = {} pkts {}/{} start {} preroll {}", stream_no, sname, maxps, avgps, start, preroll);
410	let mime_size = self.src.read_byte()? as usize;
411	let mime = read_string_size(self.src, mime_size)?;
412	println!("mime = {}", mime);
413	let edata_size = self.src.read_u32be()? as usize;
414	let edata: Option<Vec<u8>> = if edata_size == 0 { None } else {
415	let mut edvec: Vec<u8> = Vec::with_capacity(edata_size);
416	edvec.resize(edata_size, 0);
417	self.src.read_buf(&mut edvec)?;
418	Some(edvec)
419	};
420	self.str_ids.push(stream_no);
421	if edata_size > 8 {
422	if let Some(edata_) = edata {
423	let mut mr = MemoryReader::new_read(edata_.as_slice());
424	let mut src = ByteReader::new(&mut mr);
425
426	let tag = src.read_u32be()?;
427	let tag2 = src.peek_u32be()?;
428	println!("tag1 {:X} tag2 {:X}", tag, tag2);
429	if tag == mktag!('.', 'r', 'a', 0xFD) {
430	//todo audio
431	let cname = "unknown";//find_codec_name(RM_AUDIO_CODEC_REGISTER, fcc);
432	let soniton = NASoniton::new(16, SONITON_FLAG_SIGNED);
433	let ahdr = NAAudioInfo::new(44100, 2, soniton, 1/block_align as usize/);
434	let extradata = None;
435	let ainfo = NACodecInfo::new(cname, NACodecTypeInfo::Audio(ahdr), extradata);
436	let res = strmgr.add_stream(NAStream::new(StreamType::Audio, stream_no as u32, ainfo, 1, 44100));
437	if res.is_none() { return Err(MemoryError); }
438
439	let astr = RMAudioStream::new(Deinterleaver::None);
440	self.streams.push(RMStreamType::Audio(astr));
441	} else if ((tag2 == mktag!('V', 'I', 'D', 'O')) \|\| (tag2 == mktag!('I', 'M', 'A', 'G'))) && ((tag as usize) <= edata_size) {
442	src.read_skip(4)?;
443	let fcc = src.read_u32be()?;
444	let width = src.read_u16be()? as usize;
445	let height = src.read_u16be()? as usize;
446	let bpp = src.read_u16be()?;
447	let pad_w = src.read_u16be()?;
448	let pad_h = src.read_u16be()?;
449	let fps;
450	if tag2 == mktag!('V', 'I', 'D', 'O') {
451	fps = src.read_u32be()?;
452	} else {
453	fps = 0x10000;
454	}
455	let extradata: Option<Vec<u8>>;
456	if src.left() > 0 {
457	let eslice = &edata_[(src.tell() as usize)..];
458	extradata = Some(eslice.to_vec());
459	} else {
460	extradata = None;
461	}
462	let cname = find_codec_name(RM_VIDEO_CODEC_REGISTER, fcc);
463
464	let vhdr = NAVideoInfo::new(width, height, false, RGB24_FORMAT);
465	let vinfo = NACodecInfo::new(cname, NACodecTypeInfo::Video(vhdr), extradata);
466	let res = strmgr.add_stream(NAStream::new(StreamType::Video, stream_no as u32, vinfo, 0x10000, fps));
467	if res.is_none() { return Err(DemuxerError::MemoryError); }
468
469	let vstr = RMVideoStream::new();
470	self.streams.push(RMStreamType::Video(vstr));
471	} else {
472	self.streams.push(RMStreamType::Logical);
473	}
474	}
475	} else {
476	self.streams.push(RMStreamType::Unknown);
477	}
478
479	Ok(())
480	}
481	/*#[allow(unused_variables)]
482	fn read_pkt_header(&mut self) -> DemuxerResult<()> {
483	let ver = self.src.read_u16be()?;
484	validate!(ver <= 1);
485	let str_no = self.src.read_u16be()?;
486	let timestamp = self.src.read_u32be()?;
487	if ver == 0 {
488	let pkt_group = self.src.read_byte()?;
489	let pkt_flags = self.src.read_byte()?;
490	} else {
491	let asm_rule = self.src.read_u16be()?;
492	let asm_flags = self.src.read_byte()?;
493	}
494	Ok(())
495	}*/
496	}
497
498	fn read_string(src: &mut ByteReader) -> DemuxerResult<String> {
499	let mut vec: Vec<u8> = Vec::new();
500	loop {
501	let c = src.read_byte()?;
502	if c == 0 { break; }
503	vec.push(c);
504	}
505	let str = String::from_utf8(vec);
506	if str.is_ok() {
507	Ok(str.unwrap())
508	} else {
509	Ok(String::new())
510	}
511	}
512
513	fn read_string_size(src: &mut ByteReader, size: usize) -> DemuxerResult<String> {
514	let mut vec: Vec<u8> = Vec::new();
515	for _ in 0..size {
516	let c = src.read_byte()?;
517	vec.push(c);
518	}
519	let str = String::from_utf8(vec);
520	if str.is_ok() {
521	Ok(str.unwrap())
522	} else {
523	Ok(String::new())
524	}
525	}
526
527	#[allow(dead_code)]
528	#[allow(unused_variables)]
529	fn parse_rm_stream(io: &mut ByteReader) -> DemuxerResult<NAStream> {
530	let mimetype = read_string(io)?;
531	let strname = read_string(io)?;
532	let strnum = io.read_u32le()?;
533	let maxbr = io.read_u32le()?;
534	let avgbr = io.read_u32le()?;
535	let maxsize = io.read_u32le()?;
536	let avgsize = io.read_u32le()?;
537	let duration = io.read_u32le()?;
538	let preroll = io.read_u32le()?;
539	let start = io.read_u32le()?;
540	let edatalen = io.read_u32le()? as usize;
541	let mut edata: Vec<u8> = Vec::with_capacity(edatalen);
542	edata.resize(edatalen, 0);
543	io.read_buf(&mut edata)?;
544	let numprops = io.read_u32le()? as usize;
545	//read properties
546	unimplemented!();
547	}
548
549	#[allow(dead_code)]
550	#[allow(unused_variables)]
551	fn read_ra_vbr_stream(io: &mut ByteReader) -> DemuxerResult<NAPacket> {
552	let hdrsizesize = io.read_u16le()?;
553	let num_entries = (hdrsizesize / 16) as usize;
554	let mut sizes: Vec<usize> = Vec::with_capacity(num_entries);
555	for _ in 0..num_entries {
556	let sz = io.read_u16le()? as usize;
557	sizes.push(sz);
558	}
559	for i in 0..num_entries {
560	//read packet of sizes[i]
561	}
562	unimplemented!();
563	}
564
565	//todo interleavers
566
567	//todo opaque data
568
569
570	static RM_VIDEO_CODEC_REGISTER: &'static [(&[u8;4], &str)] = &[
571	(b"RV10", "realvideo1"),
572	(b"RV20", "realvideo2"),
573	(b"RVTR", "realvideo2"),
574	(b"RV30", "realvideo3"),
575	(b"RV40", "realvideo4"),
576	(b"CLV1", "clearvideo"),
577	];
578
b1ef37ee	579	#[allow(dead_code)]
ce52b3b5 KS	580	static RM_AUDIO_CODEC_REGISTER: &'static [(&[u8;4], &str)] = &[
	581	(b"lpcJ", "ra14.4"),
	582	(b"28_8", "ra28.8"),
	583	(b"cook", "cook"),
	584	(b"dnet", "ac3"),
	585	(b"sipr", "sipro"),
	586	(b"atrc", "atrac3"),
	587	(b"LSD:", "ralf"),
	588	(b"raac", "aac"),
	589	(b"racp", "aac"),
	590	];
	591
	592	pub struct RealMediaDemuxerCreator { }
	593
	594	impl DemuxerCreator for RealMediaDemuxerCreator {
	595	fn new_demuxer<'a>(&self, br: &'a mut ByteReader<'a>) -> Box<DemuxCore<'a> + 'a> {
	596	Box::new(RealMediaDemuxer::new(br))
	597	}
	598	fn get_name(&self) -> &'static str { "realmedia" }
	599	}
	600
	601	#[cfg(test)]
	602	mod test {
	603	use super::*;
	604	use std::fs::File;
	605
	606	#[test]
	607	fn test_rm_demux() {
	608	let mut file =
	609	File::open("assets/RV/rv10_dnet_640x352_realvideo_encoder_4.0.rm").unwrap();
	610	// File::open("assets/RV/rv20_cook_640x352_realproducer_plus_8.51.rm").unwrap();
	611	// File::open("assets/RV/rv20_svt_atrc_640x352_realproducer_plus_8.51.rm").unwrap();
	612	// File::open("assets/RV/rv30_atrc_384x208_realproducer_plus_8.51.rm").unwrap();
	613	// File::open("assets/RV/rv30_chroma_drift.rm").unwrap();
	614	// File::open("assets/RV/rv30_weighted_mc.rm").unwrap();
	615	// File::open("assets/RV/rv40_weighted_mc.rmvb").unwrap();
	616	// File::open("assets/RV/rv40_weighted_mc_2.rmvb").unwrap();
	617	// File::open("assets/RV/clv1_sipr_384x208_realvideo_encoder_4.0.rm").unwrap();
	618	// File::open("assets/RV/luckynight.rmvb").unwrap();
	619	// File::open("assets/RV/rv40_ralf.rmvb").unwrap();
	620	let mut fr = FileReader::new_read(&mut file);
	621	let mut br = ByteReader::new(&mut fr);
	622	let mut dmx = RealMediaDemuxer::new(&mut br);
	623	let mut sm = StreamManager::new();
	624	dmx.open(&mut sm).unwrap();
	625
	626	loop {
	627	let pktres = dmx.get_frame(&mut sm);
	628	if let Err(e) = pktres {
	629	if e == DemuxerError::EOF { break; }
	630	panic!("error");
	631	}
	632	let pkt = pktres.unwrap();
	633	println!("Got {}", pkt);
	634	}
41f11b2b	635	//panic!("the end");
ce52b3b5 KS	636	}
ce52b3b5 KS	637	}