nihav-core/src/register.rs

   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   = 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
  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 = 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> {
 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;    "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"),
 168
 169     desc!(video;    "smacker-video", "Smacker video"),
 170     desc!(audio;    "smacker-audio", "Smacker audio"),
 171     desc!(video;    "bink-video",    "Bink video"),
 172     desc!(video;    "bink2-video",   "Bink2 video"),
 173     desc!(audio;    "bink-audio-dct",   "Bink audio (DCT)"),
 174     desc!(audio;    "bink-audio-rdft",  "Bink audio (RDFT)"),
 175 ];
 176
 177 static AVI_VIDEO_CODEC_REGISTER: &'static [(&[u8;4], &str)] = &[
 178     (b"IF09", "indeo1"),
 179     (b"RT21", "indeo2"),
 180     (b"IV31", "indeo3"),
 181     (b"IV32", "indeo3"),
 182     (b"IV41", "indeo4"),
 183     (b"IV50", "indeo5"),
 184     (b"I263", "intel263"),
 185
 186     (b"UCOD", "clearvideo"),
 187
 188     (b"DUCK", "truemotion1"),
 189     (b"TR20", "truemotionrt"),
 190     (b"TM20", "truemotion2"),
 191     (b"TM2A", "truemotion2x"),
 192     (b"TM2X", "truemotion2x"),
 193     (b"VP30", "vp3"),
 194     (b"VP31", "vp3"),
 195     (b"VP40", "vp4"),
 196     (b"VP50", "vp5"),
 197     (b"VP60", "vp6"),
 198     (b"VP61", "vp6"),
 199     (b"VP62", "vp6"),
 200     (b"VP70", "vp7"),
 201 ];
 202
 203 static WAV_CODEC_REGISTER: &'static [(u16, &str)] = &[
 204     (0x0000, "pcm"),
 205     (0x0001, "pcm"),
 206     (0x0003, "pcm"),
 207     (0x0061, "adpcm-dk4"),
 208     (0x0062, "adpcm-dk3"),
 209     (0x0401, "imc"),
 210     (0x0402, "iac"),
 211     (0x0500, "on2avc-500"),
 212     (0x0501, "on2avc-501"),
 213 ];
 214
 215 pub fn find_codec_from_avi_fourcc(fcc: &[u8;4]) -> Option<&'static str> {
 216     for i in 0..AVI_VIDEO_CODEC_REGISTER.len() {
 217         let (fourcc, name) = AVI_VIDEO_CODEC_REGISTER[i];
 218         if fourcc == fcc { return Some(name); }
 219     }
 220     None
 221 }
 222
 223 pub fn find_codec_from_wav_twocc(tcc: u16) -> Option<&'static str> {
 224     for i in 0..WAV_CODEC_REGISTER.len() {
 225         let (twocc, name) = WAV_CODEC_REGISTER[i];
 226         if twocc == tcc { return Some(name); }
 227     }
 228     None
 229 }
 230
 231 #[cfg(test)]
 232 mod test {
 233     use super::*;
 234
 235     #[test]
 236     fn test_register() {
 237         let c1 = find_codec_from_avi_fourcc(b"IV41").unwrap();
 238         let c2 = find_codec_from_wav_twocc(0x401).unwrap();
 239         println!("found {} and {}", c1, c2);
 240         let cd1 = get_codec_description(c1).unwrap();
 241         let cd2 = get_codec_description(c2).unwrap();
 242         println!("got {} and {}", cd1, cd2);
 243     }
 244 }