[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   = 0x0001;
const CODEC_CAP_LOSSLESS:u32    = 0x0002;
const CODEC_CAP_REORDER:u32     = 0x0004;
const CODEC_CAP_HYBRID:u32      = 0x0008;
const CODEC_CAP_SCALABLE:u32    = 0x0010;

#[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 = self.fname.to_string();
        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;    "vp6a",          "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;    "on2avc-500",    "On2 AVC"),
    desc!(audio;    "on2avc-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;    "midivid",       "MidiVid"),
    desc!(video;    "midivid3",      "MidiVid 3"),
    desc!(video-ll; "midivid-ll",    "MidiVid Lossless"),
    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"MVDV", "midivid"),
    (b"MV30", "midivid3"),
    (b"MVLZ", "midivid-ll"),

    (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 (fourcc, name) in AVI_VIDEO_CODEC_REGISTER.iter() {
        if *fourcc == fcc { return Some(name); }
    }
    None
}

pub fn find_codec_from_wav_twocc(tcc: u16) -> Option<&'static str> {
    for (twocc, name) in WAV_CODEC_REGISTER.iter() {
        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
	1	use std::fmt;
	2
	3	#[derive(Debug,Clone,Copy,PartialEq)]
	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 = 0x0001;
	26	const CODEC_CAP_LOSSLESS:u32 = 0x0002;
	27	const CODEC_CAP_REORDER:u32 = 0x0004;
	28	const CODEC_CAP_HYBRID:u32 = 0x0008;
	29	const CODEC_CAP_SCALABLE:u32 = 0x0010;
	30
	31	#[derive(Clone)]
	32	pub struct CodecDescription {
	33	pub name: &'static str,
	34	pub fname: &'static str,
	35	pub ctype: CodecType,
	36	pub caps: u32,
	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 = self.fname.to_string();
	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> {
	112	for reg in CODEC_REGISTER {
	113	if reg.name == name {
	114	return Some(reg);
	115	}
	116	}
	117	None
	118	}
	119
	120	static CODEC_REGISTER: &'static [CodecDescription] = &[
	121	desc!(audio-ll; "pcm", "PCM"),
	122
	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),
	128	desc!(video; "intel263", "Intel I263", CODEC_CAP_REORDER),
	129	desc!(audio; "iac", "Intel Indeo audio"),
	130	desc!(audio; "imc", "Intel Music Coder"),
	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),
	136	desc!(video; "realvideo6", "Real Video 6", CODEC_CAP_REORDER),
	137	desc!(video; "clearvideo", "ClearVideo"),
	138	desc!(video; "clearvideo_rm", "ClearVideo"),
	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"),
	144	desc!(audio; "ac3", "ETSI TS 102 366"),
	145	desc!(audio; "atrac3", "Sony Atrac3"),
	146	desc!(audio; "sipro", "Sipro Labs ADPCM"),
	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; "vp6a", "VP6"),
	157	desc!(video; "vp7", "VP7"),
	158	desc!(video; "vp8", "VP8"),
	159	desc!(video; "vp9", "VP9"),
	160	desc!(audio; "adpcm-dk3", "Duck DK3 ADPCM"),
	161	desc!(audio; "adpcm-dk4", "Duck DK4 ADPCM"),
	162	desc!(audio; "on2avc-500", "On2 AVC"),
	163	desc!(audio; "on2avc-501", "On2 AVC"),
	164
	165	desc!(video; "gdv-video", "Gremlin Digital Video - video"),
	166	desc!(audio; "gdv-audio", "Gremlin Digital Video - audio"),
	167	desc!(video; "bmv-video", "BMV video"),
	168	desc!(audio; "bmv-audio", "BMV audio"),
	169	desc!(video; "bmv3-video", "DW Noir BMV video"),
	170	desc!(audio; "bmv3-audio", "DW Noir BMV audio"),
	171	desc!(video; "midivid", "MidiVid"),
	172	desc!(video; "midivid3", "MidiVid 3"),
	173	desc!(video-ll; "midivid-ll", "MidiVid Lossless"),
	174	desc!(video; "vmd-video", "VMD video"),
	175	desc!(audio; "vmd-audio", "VMD audio"),
	176
	177	desc!(video; "smacker-video", "Smacker video"),
	178	desc!(audio; "smacker-audio", "Smacker audio"),
	179	desc!(video; "bink-video", "Bink video"),
	180	desc!(video; "bink2-video", "Bink2 video"),
	181	desc!(audio; "bink-audio-dct", "Bink audio (DCT)"),
	182	desc!(audio; "bink-audio-rdft", "Bink audio (RDFT)"),
	183	];
	184
	185	static AVI_VIDEO_CODEC_REGISTER: &'static [(&[u8;4], &str)] = &[
	186	(b"IF09", "indeo1"),
	187	(b"RT21", "indeo2"),
	188	(b"IV31", "indeo3"),
	189	(b"IV32", "indeo3"),
	190	(b"IV41", "indeo4"),
	191	(b"IV50", "indeo5"),
	192	(b"I263", "intel263"),
	193
	194	(b"UCOD", "clearvideo"),
	195
	196	(b"MVDV", "midivid"),
	197	(b"MV30", "midivid3"),
	198	(b"MVLZ", "midivid-ll"),
	199
	200	(b"DUCK", "truemotion1"),
	201	(b"TR20", "truemotionrt"),
	202	(b"TM20", "truemotion2"),
	203	(b"TM2A", "truemotion2x"),
	204	(b"TM2X", "truemotion2x"),
	205	(b"VP30", "vp3"),
	206	(b"VP31", "vp3"),
	207	(b"VP40", "vp4"),
	208	(b"VP50", "vp5"),
	209	(b"VP60", "vp6"),
	210	(b"VP61", "vp6"),
	211	(b"VP62", "vp6"),
	212	(b"VP70", "vp7"),
	213	];
	214
	215	static WAV_CODEC_REGISTER: &'static [(u16, &str)] = &[
	216	(0x0000, "pcm"),
	217	(0x0001, "pcm"),
	218	(0x0003, "pcm"),
	219	(0x0061, "adpcm-dk4"),
	220	(0x0062, "adpcm-dk3"),
	221	(0x0401, "imc"),
	222	(0x0402, "iac"),
	223	(0x0500, "on2avc-500"),
	224	(0x0501, "on2avc-501"),
	225	];
	226
	227	pub fn find_codec_from_avi_fourcc(fcc: &[u8;4]) -> Option<&'static str> {
	228	for (fourcc, name) in AVI_VIDEO_CODEC_REGISTER.iter() {
	229	if *fourcc == fcc { return Some(name); }
	230	}
	231	None
	232	}
	233
	234	pub fn find_codec_from_wav_twocc(tcc: u16) -> Option<&'static str> {
	235	for (twocc, name) in WAV_CODEC_REGISTER.iter() {
	236	if *twocc == tcc { return Some(name); }
	237	}
	238	None
	239	}
	240
	241	#[cfg(test)]
	242	mod test {
	243	use super::*;
	244
	245	#[test]
	246	fn test_register() {
	247	let c1 = find_codec_from_avi_fourcc(b"IV41").unwrap();
	248	let c2 = find_codec_from_wav_twocc(0x401).unwrap();
	249	println!("found {} and {}", c1, c2);
	250	let cd1 = get_codec_description(c1).unwrap();
	251	let cd2 = get_codec_description(c2).unwrap();
	252	println!("got {} and {}", cd1, cd2);
	253	}
	254	}