[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!(audio-ll; "pcm", "PCM"),

    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"),

    desc!(video;    "truemotion1",   "TrueMotion 1"), 
    desc!(video-im; "truemotionrt",  "TrueMotion RT"), 
    desc!(video;    "truemotion2",   "TrueMotion 2"), 
    desc!(video;    "truemotion2x",  "TrueMotion 2X"),
    desc!(video;    "vp3",           "VP3"),
    desc!(video;    "vp4",           "VP4"),
    desc!(video;    "vp5",           "VP5"),
    desc!(video;    "vp6",           "VP6"),
    desc!(video;    "vp7",           "VP7"),
    desc!(video;    "vp8",           "VP8"),
    desc!(video;    "vp9",           "VP9"),
    desc!(audio;    "adpcm-dk3",     "Duck DK3 ADPCM"),
    desc!(audio;    "adpcm-dk4",     "Duck DK4 ADPCM"),
    desc!(audio;    "on2-avc-500",   "On2 AVC"),
    desc!(audio;    "on2-avc-501",   "On2 AVC"),

    desc!(video;    "gdv-video",     "Gremlin Digital Video - video"),
    desc!(audio;    "gdv-audio",     "Gremlin Digital Video - audio"),
    desc!(video;    "bmv-video",     "BMV video"),
    desc!(audio;    "bmv-audio",     "BMV audio"),
    desc!(video;    "bmv3-video",    "DW Noir BMV video"),
    desc!(audio;    "bmv3-audio",    "DW Noir BMV audio"),
    desc!(video;    "vmd-video",     "VMD video"),
    desc!(audio;    "vmd-audio",     "VMD audio"),

    desc!(video;    "smacker-video", "Smacker video"),
    desc!(audio;    "smacker-audio", "Smacker audio"),
    desc!(video;    "bink-video",    "Bink video"),
    desc!(video;    "bink2-video",   "Bink2 video"),
    desc!(audio;    "bink-audio-dct",   "Bink audio (DCT)"),
    desc!(audio;    "bink-audio-rdft",  "Bink audio (RDFT)"),
];

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", "vp3"),
    (b"VP31", "vp3"),
    (b"VP40", "vp4"),
    (b"VP50", "vp5"),
    (b"VP60", "vp6"),
    (b"VP61", "vp6"),
    (b"VP62", "vp6"),
    (b"VP70", "vp7"),
];

static WAV_CODEC_REGISTER: &'static [(u16, &str)] = &[
    (0x0000, "pcm"),
    (0x0001, "pcm"),
    (0x0003, "pcm"),
    (0x0061, "adpcm-dk4"),
    (0x0062, "adpcm-dk3"),
    (0x0401, "imc"),
    (0x0402, "iac"),
    (0x0500, "on2avc-500"),
    (0x0501, "on2avc-501"),
];

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] = &[
e8e022f4 KS	121	desc!(audio-ll; "pcm", "PCM"),
e8e022f4 KS	122
45e794c4 KS	123	desc!(video-im; "indeo1", "Intel Raw IF09"),
	124	desc!(video-im; "indeo2", "Intel Indeo 2"),
	125	desc!(video; "indeo3", "Intel Indeo 3"),
	126	desc!(video; "indeo4", "Intel Indeo 4", CODEC_CAP_REORDER \| CODEC_CAP_SCALABLE),
	127	desc!(video; "indeo5", "Intel Indeo 5", CODEC_CAP_REORDER \| CODEC_CAP_SCALABLE),
1a36a05d	128	desc!(video; "intel263", "Intel I263", CODEC_CAP_REORDER),
45e794c4 KS	129	desc!(audio; "iac", "Intel Indeo audio"),
45e794c4 KS	130	desc!(audio; "imc", "Intel Music Coder"),
ce52b3b5 KS	131
	132	desc!(video; "realvideo1", "Real Video 1"),
	133	desc!(video; "realvideo2", "Real Video 2"),
	134	desc!(video; "realvideo3", "Real Video 3", CODEC_CAP_REORDER),
	135	desc!(video; "realvideo4", "Real Video 4", CODEC_CAP_REORDER),
0b791d5c	136	desc!(video; "realvideo6", "Real Video 6", CODEC_CAP_REORDER),
ce52b3b5	137	desc!(video; "clearvideo", "ClearVideo"),
750b299c	138	desc!(video; "clearvideo_rm", "ClearVideo"),
ce52b3b5 KS	139	desc!(audio; "ra14.4", "RealAudio 14.4"),
	140	desc!(audio; "ra28.8", "RealAudio 28.8"),
	141	desc!(audio; "cook", "RealAudio Cooker"),
	142	desc!(audio; "ralf", "RealAudio Lossless"),
	143	desc!(audio; "aac", "AAC"),
16dd4f44	144	desc!(audio; "ac3", "ETSI TS 102 366"),
ce52b3b5 KS	145	desc!(audio; "atrac3", "Sony Atrac3"),
ce52b3b5 KS	146	desc!(audio; "sipro", "Sipro Labs ADPCM"),
e8e022f4 KS	147
	148	desc!(video; "truemotion1", "TrueMotion 1"),
	149	desc!(video-im; "truemotionrt", "TrueMotion RT"),
	150	desc!(video; "truemotion2", "TrueMotion 2"),
	151	desc!(video; "truemotion2x", "TrueMotion 2X"),
	152	desc!(video; "vp3", "VP3"),
	153	desc!(video; "vp4", "VP4"),
	154	desc!(video; "vp5", "VP5"),
	155	desc!(video; "vp6", "VP6"),
	156	desc!(video; "vp7", "VP7"),
	157	desc!(video; "vp8", "VP8"),
	158	desc!(video; "vp9", "VP9"),
	159	desc!(audio; "adpcm-dk3", "Duck DK3 ADPCM"),
	160	desc!(audio; "adpcm-dk4", "Duck DK4 ADPCM"),
	161	desc!(audio; "on2-avc-500", "On2 AVC"),
	162	desc!(audio; "on2-avc-501", "On2 AVC"),
	163
	164	desc!(video; "gdv-video", "Gremlin Digital Video - video"),
	165	desc!(audio; "gdv-audio", "Gremlin Digital Video - audio"),
	166	desc!(video; "bmv-video", "BMV video"),
	167	desc!(audio; "bmv-audio", "BMV audio"),
ecda1cc1 KS	168	desc!(video; "bmv3-video", "DW Noir BMV video"),
ecda1cc1 KS	169	desc!(audio; "bmv3-audio", "DW Noir BMV audio"),
9895bd7b KS	170	desc!(video; "vmd-video", "VMD video"),
9895bd7b KS	171	desc!(audio; "vmd-audio", "VMD audio"),
e8e022f4 KS	172
	173	desc!(video; "smacker-video", "Smacker video"),
	174	desc!(audio; "smacker-audio", "Smacker audio"),
	175	desc!(video; "bink-video", "Bink video"),
	176	desc!(video; "bink2-video", "Bink2 video"),
	177	desc!(audio; "bink-audio-dct", "Bink audio (DCT)"),
	178	desc!(audio; "bink-audio-rdft", "Bink audio (RDFT)"),
d48ee414 KS	179	];
	180
	181	static AVI_VIDEO_CODEC_REGISTER: &'static [(&[u8;4], &str)] = &[
45e794c4 KS	182	(b"IF09", "indeo1"),
	183	(b"RT21", "indeo2"),
	184	(b"IV31", "indeo3"),
	185	(b"IV32", "indeo3"),
	186	(b"IV41", "indeo4"),
	187	(b"IV50", "indeo5"),
836bf150	188	(b"I263", "intel263"),
ce52b3b5	189
750b299c	190	(b"UCOD", "clearvideo"),
b2d656d0 KS	191
	192	(b"DUCK", "truemotion1"),
	193	(b"TR20", "truemotionrt"),
	194	(b"TM20", "truemotion2"),
	195	(b"TM2A", "truemotion2x"),
	196	(b"TM2X", "truemotion2x"),
40e95291 KS	197	(b"VP30", "vp3"),
	198	(b"VP31", "vp3"),
	199	(b"VP40", "vp4"),
	200	(b"VP50", "vp5"),
	201	(b"VP60", "vp6"),
	202	(b"VP61", "vp6"),
	203	(b"VP62", "vp6"),
	204	(b"VP70", "vp7"),
d48ee414 KS	205	];
	206
	207	static WAV_CODEC_REGISTER: &'static [(u16, &str)] = &[
45e794c4 KS	208	(0x0000, "pcm"),
	209	(0x0001, "pcm"),
	210	(0x0003, "pcm"),
fadee95f KS	211	(0x0061, "adpcm-dk4"),
fadee95f KS	212	(0x0062, "adpcm-dk3"),
45e794c4 KS	213	(0x0401, "imc"),
45e794c4 KS	214	(0x0402, "iac"),
a38be6e4 KS	215	(0x0500, "on2avc-500"),
a38be6e4 KS	216	(0x0501, "on2avc-501"),
d48ee414 KS	217	];
	218
	219	pub fn find_codec_from_avi_fourcc(fcc: &[u8;4]) -> Option<&'static str> {
	220	for i in 0..AVI_VIDEO_CODEC_REGISTER.len() {
	221	let (fourcc, name) = AVI_VIDEO_CODEC_REGISTER[i];
	222	if fourcc == fcc { return Some(name); }
	223	}
	224	None
	225	}
	226
	227	pub fn find_codec_from_wav_twocc(tcc: u16) -> Option<&'static str> {
	228	for i in 0..WAV_CODEC_REGISTER.len() {
	229	let (twocc, name) = WAV_CODEC_REGISTER[i];
	230	if twocc == tcc { return Some(name); }
	231	}
	232	None
	233	}
	234
	235	#[cfg(test)]
	236	mod test {
	237	use super::*;
	238
	239	#[test]
	240	fn test_register() {
	241	let c1 = find_codec_from_avi_fourcc(b"IV41").unwrap();
	242	let c2 = find_codec_from_wav_twocc(0x401).unwrap();
	243	println!("found {} and {}", c1, c2);
	244	let cd1 = get_codec_description(c1).unwrap();
	245	let cd2 = get_codec_description(c2).unwrap();
	246	println!("got {} and {}", cd1, cd2);
	247	}
b58d7656	248	}