[nihav.git] / nihav-core / src / register.rs

use std::fmt;

#[derive(Debug,Clone,Copy,PartialEq)]
#[allow(dead_code)]
pub enum CodecType {
    Video,
    Audio,
    Subtitles,
    Data,
    None,
}

impl fmt::Display for CodecType {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {
            CodecType::Video => write!(f, "Video"),
            CodecType::Audio => write!(f, "Audio"),
            CodecType::Subtitles => write!(f, "Subtitles"),
            CodecType::Data => write!(f, "Data"),
            CodecType::None => write!(f, "-"),
        }
    }
}

const CODEC_CAP_INTRAONLY:u32   = 0x000001;
const CODEC_CAP_LOSSLESS:u32    = 0x000002;
const CODEC_CAP_REORDER:u32     = 0x000004;
const CODEC_CAP_HYBRID:u32      = 0x000008;
const CODEC_CAP_SCALABLE:u32    = 0x000010;

#[derive(Clone)]
pub struct CodecDescription {
    pub name:  &'static str,
    pub fname: &'static str,
    pub ctype: CodecType,
    pub caps:  u32,
}

impl CodecDescription {
    pub fn get_name(&self) -> &'static str { self.name }
    pub fn get_full_name(&self) -> &'static str { self.fname }
    pub fn get_codec_type(&self) -> CodecType { self.ctype }
    pub fn is_intraonly(&self) -> bool { (self.caps & CODEC_CAP_INTRAONLY) != 0 }
    pub fn is_lossless(&self)  -> bool { (self.caps & CODEC_CAP_LOSSLESS)  != 0 }
    pub fn has_reorder(&self)  -> bool { (self.caps & CODEC_CAP_REORDER)   != 0 }
    pub fn is_hybrid(&self)    -> bool { (self.caps & CODEC_CAP_HYBRID)    != 0 }
    pub fn is_scalable(&self)  -> bool { (self.caps & CODEC_CAP_SCALABLE)  != 0 }
}

impl fmt::Display for CodecDescription {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        let mut out = format!("{}", self.fname);
        if self.caps != 0 {
            let mut capfmt = "".to_string();
            if (self.caps & CODEC_CAP_INTRAONLY) != 0 {
                capfmt = format!("{} Intra-only", capfmt);
            }
            if (self.caps & CODEC_CAP_LOSSLESS) != 0 {
                capfmt = format!("{} Lossless", capfmt);
            }
            if (self.caps & CODEC_CAP_REORDER) != 0 {
                capfmt = format!("{} Frame reorder", capfmt);
            }
            if (self.caps & CODEC_CAP_HYBRID) != 0 {
                capfmt = format!("{} Can be lossy and lossless", capfmt);
            }
            if (self.caps & CODEC_CAP_SCALABLE) != 0 {
                capfmt = format!("{} Scalable", capfmt);
            }
            out = format!("{} ({})", out, capfmt);
        }
        write!(f, "{}", out)
    }
}

macro_rules! desc {
    (video; $n:expr, $fn:expr) => ({
        CodecDescription{ name: $n, fname: $fn, ctype: CodecType::Video,
                          caps: 0 }
    });
    (video; $n:expr, $fn:expr, $c:expr) => ({
        CodecDescription{ name: $n, fname: $fn, ctype: CodecType::Video,
                          caps: $c }
    });
    (video-ll; $n:expr, $fn:expr) => ({
        CodecDescription{ name: $n, fname: $fn, ctype: CodecType::Video,
                          caps: CODEC_CAP_LOSSLESS | CODEC_CAP_INTRAONLY }
    });
    (video-llp; $n:expr, $fn:expr) => ({
        CodecDescription{ name: $n, fname: $fn, ctype: CodecType::Video,
                          caps: CODEC_CAP_LOSSLESS }
    });
    (video-im; $n:expr, $fn:expr) => ({
        CodecDescription{ name: $n, fname: $fn, ctype: CodecType::Video,
                          caps: CODEC_CAP_INTRAONLY }
    });
    (video-modern; $n:expr, $fn:expr) => ({
        CodecDescription{ name: $n, fname: $fn, ctype: CodecType::Video,
                          caps: CODEC_CAP_REORDER | CODEC_CAP_HYBRID }
    });
    (audio; $n:expr, $fn:expr) => ({
        CodecDescription{ name: $n, fname: $fn, ctype: CodecType::Audio,
                          caps: 0 }
    });
    (audio-ll; $n:expr, $fn:expr) => ({
        CodecDescription{ name: $n, fname: $fn, ctype: CodecType::Audio,
                          caps: CODEC_CAP_LOSSLESS | CODEC_CAP_INTRAONLY }
    });
}

pub fn get_codec_description(name: &str) -> Option<&'static CodecDescription> {
    for reg in CODEC_REGISTER {
        if reg.name == name {
            return Some(reg);
        }
    }
    None
}

static CODEC_REGISTER: &'static [CodecDescription] = &[
    desc!(video-im; "indeo1", "Intel Raw IF09"),
    desc!(video-im; "indeo2", "Intel Indeo 2"),
    desc!(video;    "indeo3", "Intel Indeo 3"),
    desc!(video;    "indeo4", "Intel Indeo 4", CODEC_CAP_REORDER | CODEC_CAP_SCALABLE),
    desc!(video;    "indeo5", "Intel Indeo 5", CODEC_CAP_REORDER | CODEC_CAP_SCALABLE),
    desc!(video;    "intel263", "Intel I263", CODEC_CAP_REORDER),
    desc!(audio;    "iac",    "Intel Indeo audio"),
    desc!(audio;    "imc",    "Intel Music Coder"),

    desc!(video;    "realvideo1", "Real Video 1"),
    desc!(video;    "realvideo2", "Real Video 2"),
    desc!(video;    "realvideo3", "Real Video 3", CODEC_CAP_REORDER),
    desc!(video;    "realvideo4", "Real Video 4", CODEC_CAP_REORDER),
    desc!(video;    "realvideo6", "Real Video 6", CODEC_CAP_REORDER),
    desc!(video;    "clearvideo", "ClearVideo"),
    desc!(video;    "clearvideo_rm", "ClearVideo"),
    desc!(audio;    "ra14.4",     "RealAudio 14.4"),
    desc!(audio;    "ra28.8",     "RealAudio 28.8"),
    desc!(audio;    "cook",       "RealAudio Cooker"),
    desc!(audio;    "ralf",       "RealAudio Lossless"),
    desc!(audio;    "aac",        "AAC"),
    desc!(audio;    "ac3",        "ETSI TS 102 366"),
    desc!(audio;    "atrac3",     "Sony Atrac3"),
    desc!(audio;    "sipro",      "Sipro Labs ADPCM"),
];

static AVI_VIDEO_CODEC_REGISTER: &'static [(&[u8;4], &str)] = &[
    (b"IF09", "indeo1"),
    (b"RT21", "indeo2"),
    (b"IV31", "indeo3"),
    (b"IV32", "indeo3"),
    (b"IV41", "indeo4"),
    (b"IV50", "indeo5"),
    (b"I263", "intel263"),

    (b"UCOD", "clearvideo"),

    (b"DUCK", "truemotion1"),
    (b"TR20", "truemotionrt"),
    (b"TM20", "truemotion2"),
    (b"TM2A", "truemotion2x"),
    (b"TM2X", "truemotion2x"),
    (b"VP30", "truemotion3"),
    (b"VP31", "truemotion3"),
    (b"VP40", "truemotion4"),
    (b"VP50", "truemotion5"),
    (b"VP60", "truemotion6"),
    (b"VP61", "truemotion6"),
    (b"VP62", "truemotion6"),
    (b"VP70", "truemotion7"),
];

static WAV_CODEC_REGISTER: &'static [(u16, &str)] = &[
    (0x0000, "pcm"),
    (0x0001, "pcm"),
    (0x0003, "pcm"),
    (0x0401, "imc"),
    (0x0402, "iac"),
];

pub fn find_codec_from_avi_fourcc(fcc: &[u8;4]) -> Option<&'static str> {
    for i in 0..AVI_VIDEO_CODEC_REGISTER.len() {
        let (fourcc, name) = AVI_VIDEO_CODEC_REGISTER[i];
        if fourcc == fcc { return Some(name); }
    }
    None
}

pub fn find_codec_from_wav_twocc(tcc: u16) -> Option<&'static str> {
    for i in 0..WAV_CODEC_REGISTER.len() {
        let (twocc, name) = WAV_CODEC_REGISTER[i];
        if twocc == tcc { return Some(name); }
    }
    None
}

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

    #[test]
    fn test_register() {
        let c1 = find_codec_from_avi_fourcc(b"IV41").unwrap();
        let c2 = find_codec_from_wav_twocc(0x401).unwrap();
        println!("found {} and {}", c1, c2);
        let cd1 = get_codec_description(c1).unwrap();
        let cd2 = get_codec_description(c2).unwrap();
        println!("got {} and {}", cd1, cd2);
    }
}
Commit	Line	Data
d48ee414 KS	1	use std::fmt;
d48ee414 KS	2
34829caa	3	#[derive(Debug,Clone,Copy,PartialEq)]
d48ee414 KS	4	#[allow(dead_code)]
	5	pub enum CodecType {
	6	Video,
	7	Audio,
	8	Subtitles,
	9	Data,
	10	None,
	11	}
	12
	13	impl fmt::Display for CodecType {
	14	fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
	15	match *self {
	16	CodecType::Video => write!(f, "Video"),
	17	CodecType::Audio => write!(f, "Audio"),
	18	CodecType::Subtitles => write!(f, "Subtitles"),
	19	CodecType::Data => write!(f, "Data"),
	20	CodecType::None => write!(f, "-"),
	21	}
	22	}
	23	}
	24
	25	const CODEC_CAP_INTRAONLY:u32 = 0x000001;
	26	const CODEC_CAP_LOSSLESS:u32 = 0x000002;
	27	const CODEC_CAP_REORDER:u32 = 0x000004;
	28	const CODEC_CAP_HYBRID:u32 = 0x000008;
	29	const CODEC_CAP_SCALABLE:u32 = 0x000010;
	30
34829caa	31	#[derive(Clone)]
d48ee414	32	pub struct CodecDescription {
5641dccf KS	33	pub name: &'static str,
	34	pub fname: &'static str,
	35	pub ctype: CodecType,
	36	pub caps: u32,
d48ee414 KS	37	}
	38
	39	impl CodecDescription {
	40	pub fn get_name(&self) -> &'static str { self.name }
	41	pub fn get_full_name(&self) -> &'static str { self.fname }
	42	pub fn get_codec_type(&self) -> CodecType { self.ctype }
	43	pub fn is_intraonly(&self) -> bool { (self.caps & CODEC_CAP_INTRAONLY) != 0 }
	44	pub fn is_lossless(&self) -> bool { (self.caps & CODEC_CAP_LOSSLESS) != 0 }
	45	pub fn has_reorder(&self) -> bool { (self.caps & CODEC_CAP_REORDER) != 0 }
	46	pub fn is_hybrid(&self) -> bool { (self.caps & CODEC_CAP_HYBRID) != 0 }
	47	pub fn is_scalable(&self) -> bool { (self.caps & CODEC_CAP_SCALABLE) != 0 }
	48	}
	49
	50	impl fmt::Display for CodecDescription {
	51	fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
	52	let mut out = format!("{}", self.fname);
	53	if self.caps != 0 {
	54	let mut capfmt = "".to_string();
	55	if (self.caps & CODEC_CAP_INTRAONLY) != 0 {
	56	capfmt = format!("{} Intra-only", capfmt);
	57	}
	58	if (self.caps & CODEC_CAP_LOSSLESS) != 0 {
	59	capfmt = format!("{} Lossless", capfmt);
	60	}
	61	if (self.caps & CODEC_CAP_REORDER) != 0 {
	62	capfmt = format!("{} Frame reorder", capfmt);
	63	}
	64	if (self.caps & CODEC_CAP_HYBRID) != 0 {
	65	capfmt = format!("{} Can be lossy and lossless", capfmt);
	66	}
	67	if (self.caps & CODEC_CAP_SCALABLE) != 0 {
	68	capfmt = format!("{} Scalable", capfmt);
	69	}
	70	out = format!("{} ({})", out, capfmt);
	71	}
	72	write!(f, "{}", out)
	73	}
	74	}
	75
	76	macro_rules! desc {
	77	(video; $n:expr, $fn:expr) => ({
	78	CodecDescription{ name: $n, fname: $fn, ctype: CodecType::Video,
	79	caps: 0 }
	80	});
	81	(video; $n:expr, $fn:expr, $c:expr) => ({
	82	CodecDescription{ name: $n, fname: $fn, ctype: CodecType::Video,
	83	caps: $c }
	84	});
	85	(video-ll; $n:expr, $fn:expr) => ({
	86	CodecDescription{ name: $n, fname: $fn, ctype: CodecType::Video,
	87	caps: CODEC_CAP_LOSSLESS \| CODEC_CAP_INTRAONLY }
	88	});
	89	(video-llp; $n:expr, $fn:expr) => ({
	90	CodecDescription{ name: $n, fname: $fn, ctype: CodecType::Video,
	91	caps: CODEC_CAP_LOSSLESS }
	92	});
	93	(video-im; $n:expr, $fn:expr) => ({
	94	CodecDescription{ name: $n, fname: $fn, ctype: CodecType::Video,
	95	caps: CODEC_CAP_INTRAONLY }
	96	});
	97	(video-modern; $n:expr, $fn:expr) => ({
	98	CodecDescription{ name: $n, fname: $fn, ctype: CodecType::Video,
	99	caps: CODEC_CAP_REORDER \| CODEC_CAP_HYBRID }
	100	});
101	(audio; $n:expr, $fn:expr) => ({
102	CodecDescription{ name: $n, fname: $fn, ctype: CodecType::Audio,
103	caps: 0 }
104	});
105	(audio-ll; $n:expr, $fn:expr) => ({
106	CodecDescription{ name: $n, fname: $fn, ctype: CodecType::Audio,
107	caps: CODEC_CAP_LOSSLESS \| CODEC_CAP_INTRAONLY }
108	});
109	}
110
111	pub fn get_codec_description(name: &str) -> Option<&'static CodecDescription> {
34829caa KS	112	for reg in CODEC_REGISTER {
	113	if reg.name == name {
	114	return Some(reg);
d48ee414 KS	115	}
	116	}
	117	None
	118	}
	119
	120	static CODEC_REGISTER: &'static [CodecDescription] = &[
45e794c4 KS	121	desc!(video-im; "indeo1", "Intel Raw IF09"),
	122	desc!(video-im; "indeo2", "Intel Indeo 2"),
	123	desc!(video; "indeo3", "Intel Indeo 3"),
	124	desc!(video; "indeo4", "Intel Indeo 4", CODEC_CAP_REORDER \| CODEC_CAP_SCALABLE),
	125	desc!(video; "indeo5", "Intel Indeo 5", CODEC_CAP_REORDER \| CODEC_CAP_SCALABLE),
1a36a05d	126	desc!(video; "intel263", "Intel I263", CODEC_CAP_REORDER),
45e794c4 KS	127	desc!(audio; "iac", "Intel Indeo audio"),
45e794c4 KS	128	desc!(audio; "imc", "Intel Music Coder"),
ce52b3b5 KS	129
	130	desc!(video; "realvideo1", "Real Video 1"),
	131	desc!(video; "realvideo2", "Real Video 2"),
	132	desc!(video; "realvideo3", "Real Video 3", CODEC_CAP_REORDER),
	133	desc!(video; "realvideo4", "Real Video 4", CODEC_CAP_REORDER),
0b791d5c	134	desc!(video; "realvideo6", "Real Video 6", CODEC_CAP_REORDER),
ce52b3b5	135	desc!(video; "clearvideo", "ClearVideo"),
750b299c	136	desc!(video; "clearvideo_rm", "ClearVideo"),
ce52b3b5 KS	137	desc!(audio; "ra14.4", "RealAudio 14.4"),
	138	desc!(audio; "ra28.8", "RealAudio 28.8"),
	139	desc!(audio; "cook", "RealAudio Cooker"),
	140	desc!(audio; "ralf", "RealAudio Lossless"),
	141	desc!(audio; "aac", "AAC"),
16dd4f44	142	desc!(audio; "ac3", "ETSI TS 102 366"),
ce52b3b5 KS	143	desc!(audio; "atrac3", "Sony Atrac3"),
ce52b3b5 KS	144	desc!(audio; "sipro", "Sipro Labs ADPCM"),
d48ee414 KS	145	];
	146
	147	static AVI_VIDEO_CODEC_REGISTER: &'static [(&[u8;4], &str)] = &[
45e794c4 KS	148	(b"IF09", "indeo1"),
	149	(b"RT21", "indeo2"),
	150	(b"IV31", "indeo3"),
	151	(b"IV32", "indeo3"),
	152	(b"IV41", "indeo4"),
	153	(b"IV50", "indeo5"),
836bf150	154	(b"I263", "intel263"),
ce52b3b5	155
750b299c	156	(b"UCOD", "clearvideo"),
b2d656d0 KS	157
	158	(b"DUCK", "truemotion1"),
	159	(b"TR20", "truemotionrt"),
	160	(b"TM20", "truemotion2"),
	161	(b"TM2A", "truemotion2x"),
	162	(b"TM2X", "truemotion2x"),
	163	(b"VP30", "truemotion3"),
	164	(b"VP31", "truemotion3"),
	165	(b"VP40", "truemotion4"),
	166	(b"VP50", "truemotion5"),
	167	(b"VP60", "truemotion6"),
	168	(b"VP61", "truemotion6"),
	169	(b"VP62", "truemotion6"),
	170	(b"VP70", "truemotion7"),
d48ee414 KS	171	];
	172
	173	static WAV_CODEC_REGISTER: &'static [(u16, &str)] = &[
45e794c4 KS	174	(0x0000, "pcm"),
	175	(0x0001, "pcm"),
	176	(0x0003, "pcm"),
	177	(0x0401, "imc"),
	178	(0x0402, "iac"),
d48ee414 KS	179	];
	180
	181	pub fn find_codec_from_avi_fourcc(fcc: &[u8;4]) -> Option<&'static str> {
	182	for i in 0..AVI_VIDEO_CODEC_REGISTER.len() {
	183	let (fourcc, name) = AVI_VIDEO_CODEC_REGISTER[i];
	184	if fourcc == fcc { return Some(name); }
	185	}
	186	None
	187	}
	188
	189	pub fn find_codec_from_wav_twocc(tcc: u16) -> Option<&'static str> {
	190	for i in 0..WAV_CODEC_REGISTER.len() {
	191	let (twocc, name) = WAV_CODEC_REGISTER[i];
	192	if twocc == tcc { return Some(name); }
	193	}
	194	None
	195	}
	196
	197	#[cfg(test)]
	198	mod test {
	199	use super::*;
	200
	201	#[test]
	202	fn test_register() {
	203	let c1 = find_codec_from_avi_fourcc(b"IV41").unwrap();
	204	let c2 = find_codec_from_wav_twocc(0x401).unwrap();
	205	println!("found {} and {}", c1, c2);
	206	let cd1 = get_codec_description(c1).unwrap();
	207	let cd2 = get_codec_description(c2).unwrap();
	208	println!("got {} and {}", cd1, cd2);
	209	}
b58d7656	210	}