[nihav.git] / src / codecs / mod.rs

use std::fmt;
use std::ops::{Add, AddAssign, Sub, SubAssign};

use frame::*;
use std::rc::Rc;
use std::cell::RefCell;
use std::mem;
use io::byteio::ByteIOError;
use io::bitreader::BitReaderError;
use io::codebook::CodebookError;

#[derive(Debug,Clone,Copy,PartialEq)]
#[allow(dead_code)]
pub enum DecoderError {
    NoFrame,
    AllocError,
    TryAgain,
    InvalidData,
    ShortData,
    MissingReference,
    NotImplemented,
    Bug,
}

pub type DecoderResult<T> = Result<T, DecoderError>;

impl From<ByteIOError> for DecoderError {
    fn from(_: ByteIOError) -> Self { DecoderError::ShortData }
}

impl From<BitReaderError> for DecoderError {
    fn from(e: BitReaderError) -> Self {
        match e {
            BitReaderError::BitstreamEnd => DecoderError::ShortData,
            _ => DecoderError::InvalidData,
        }
    }
}

impl From<CodebookError> for DecoderError {
    fn from(_: CodebookError) -> Self { DecoderError::InvalidData }
}

impl From<AllocatorError> for DecoderError {
    fn from(_: AllocatorError) -> Self { DecoderError::AllocError }
}

macro_rules! validate {
    ($a:expr) => { if !$a { println!("check failed at {}:{}", file!(), line!()); return Err(DecoderError::InvalidData); } };
}

#[allow(dead_code)]
struct HAMShuffler {
    lastframe: Option<NAVideoBuffer<u8>>,
}

impl HAMShuffler {
    #[allow(dead_code)]
    fn new() -> Self { HAMShuffler { lastframe: None } }
    #[allow(dead_code)]
    fn clear(&mut self) { self.lastframe = None; }
    #[allow(dead_code)]
    fn add_frame(&mut self, buf: NAVideoBuffer<u8>) {
        self.lastframe = Some(buf);
    }
    #[allow(dead_code)]
    fn clone_ref(&mut self) -> Option<NAVideoBuffer<u8>> {
        if let Some(ref mut frm) = self.lastframe {
            let newfrm = frm.copy_buffer();
            *frm = newfrm.clone();
            Some(newfrm)
        } else {
            None
        }
    }
    #[allow(dead_code)]
    fn get_output_frame(&mut self) -> Option<NAVideoBuffer<u8>> {
        match self.lastframe {
            Some(ref frm) => Some(frm.clone()),
            None => None,
        }
    }
}

#[allow(dead_code)]
struct IPShuffler {
    lastframe: Option<NAVideoBuffer<u8>>,
}

impl IPShuffler {
    #[allow(dead_code)]
    fn new() -> Self { IPShuffler { lastframe: None } }
    #[allow(dead_code)]
    fn clear(&mut self) { self.lastframe = None; }
    #[allow(dead_code)]
    fn add_frame(&mut self, buf: NAVideoBuffer<u8>) {
        self.lastframe = Some(buf);
    }
    #[allow(dead_code)]
    fn get_ref(&mut self) -> Option<NAVideoBuffer<u8>> {
        if let Some(ref frm) = self.lastframe {
            Some(frm.clone())
        } else {
            None
        }
    }
}

#[allow(dead_code)]
struct IPBShuffler {
    lastframe: Option<NAVideoBuffer<u8>>,
    nextframe: Option<NAVideoBuffer<u8>>,
}

impl IPBShuffler {
    #[allow(dead_code)]
    fn new() -> Self { IPBShuffler { lastframe: None, nextframe: None } }
    #[allow(dead_code)]
    fn clear(&mut self) { self.lastframe = None; self.nextframe = None; }
    #[allow(dead_code)]
    fn add_frame(&mut self, buf: NAVideoBuffer<u8>) {
        mem::swap(&mut self.lastframe, &mut self.nextframe);
        self.lastframe = Some(buf);
    }
    #[allow(dead_code)]
    fn get_lastref(&mut self) -> Option<NAVideoBuffer<u8>> {
        if let Some(ref frm) = self.lastframe {
            Some(frm.clone())
        } else {
            None
        }
    }
    #[allow(dead_code)]
    fn get_nextref(&mut self) -> Option<NAVideoBuffer<u8>> {
        if let Some(ref frm) = self.nextframe {
            Some(frm.clone())
        } else {
            None
        }
    }
    #[allow(dead_code)]
    fn get_b_fwdref(&mut self) -> Option<NAVideoBuffer<u8>> {
        if let Some(ref frm) = self.nextframe {
            Some(frm.clone())
        } else {
            None
        }
    }
    #[allow(dead_code)]
    fn get_b_bwdref(&mut self) -> Option<NAVideoBuffer<u8>> {
        if let Some(ref frm) = self.lastframe {
            Some(frm.clone())
        } else {
            None
        }
    }
}

#[derive(Debug,Clone,Copy,PartialEq)]
pub struct MV {
    pub x: i16,
    pub y: i16,
}

impl MV {
    pub fn new(x: i16, y: i16) -> Self { MV{ x: x, y: y } }
    pub fn pred(a: MV, b: MV, c: MV) -> Self {
        let x;
        if a.x < b.x {
            if b.x < c.x {
                x = b.x;
            } else {
                if a.x < c.x { x = c.x; } else { x = a.x; }
            }
        } else {
            if b.x < c.x {
                if a.x < c.x { x = a.x; } else { x = c.x; }
            } else {
                x = b.x;
            }
        }
        let y;
        if a.y < b.y {
            if b.y < c.y {
                y = b.y;
            } else {
                if a.y < c.y { y = c.y; } else { y = a.y; }
            }
        } else {
            if b.y < c.y {
                if a.y < c.y { y = a.y; } else { y = c.y; }
            } else {
                y = b.y;
            }
        }
        MV { x: x, y: y }
    }
}

pub const ZERO_MV: MV = MV { x: 0, y: 0 };

impl Add for MV {
    type Output = MV;
    fn add(self, other: MV) -> MV { MV { x: self.x + other.x, y: self.y + other.y } }
}

impl AddAssign for MV {
    fn add_assign(&mut self, other: MV) { self.x += other.x; self.y += other.y; }
}

impl Sub for MV {
    type Output = MV;
    fn sub(self, other: MV) -> MV { MV { x: self.x - other.x, y: self.y - other.y } }
}

impl SubAssign for MV {
    fn sub_assign(&mut self, other: MV) { self.x -= other.x; self.y -= other.y; }
}

impl fmt::Display for MV {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{},{}", self.x, self.y)
    }
}


pub trait NADecoder {
    fn init(&mut self, info: Rc<NACodecInfo>) -> DecoderResult<()>;
    fn decode(&mut self, pkt: &NAPacket) -> DecoderResult<NAFrameRef>;
}

#[derive(Clone,Copy)]
pub struct DecoderInfo {
    name: &'static str,
    get_decoder: fn () -> Box<NADecoder>,
}

#[cfg(any(feature="h263", feature="decoder_realvideo3", feature="decoder_realvideo4"))]
mod blockdsp;

#[cfg(feature="decoder_clearvideo")]
mod clearvideo;
#[cfg(feature="decoder_gdvvid")]
mod gremlinvideo;
#[cfg(any(feature="decoder_indeo2", feature="decoder_indeo3", feature="decoder_indeo4", feature="decoder_indeo5", feature="decoder_imc"))]
mod indeo;
#[cfg(feature="h263")]
mod h263;
#[cfg(any(feature="decoder_realvideo3", feature="decoder_realvideo4", feature="decoder_realvideo6", feature="decoder_realaudio144", feature="decoder_realaudio288", feature="decoder_cook", feature="decoder_ralf"))]
mod real;

#[cfg(feature="decoder_aac")]
mod aac;
#[cfg(feature="decoder_atrac3")]
mod atrac3;
#[cfg(feature="decoder_pcm")]
mod pcm;
#[cfg(feature="decoder_sipro")]
mod sipro;
#[cfg(feature="decoder_ts102366")]
mod ts102366;

const DECODERS: &[DecoderInfo] = &[
#[cfg(feature="decoder_clearvideo")]
    DecoderInfo { name: "clearvideo", get_decoder: clearvideo::get_decoder },
#[cfg(feature="decoder_clearvideo")]
    DecoderInfo { name: "clearvideo_rm", get_decoder: clearvideo::get_decoder_rm },
#[cfg(feature="decoder_gdvvid")]
    DecoderInfo { name: "gdv-video", get_decoder: gremlinvideo::get_decoder },
#[cfg(feature="decoder_indeo2")]
    DecoderInfo { name: "indeo2", get_decoder: indeo::indeo2::get_decoder },
#[cfg(feature="decoder_indeo3")]
    DecoderInfo { name: "indeo3", get_decoder: indeo::indeo3::get_decoder },
#[cfg(feature="decoder_indeo4")]
    DecoderInfo { name: "indeo4", get_decoder: indeo::indeo4::get_decoder },
#[cfg(feature="decoder_indeo5")]
    DecoderInfo { name: "indeo5", get_decoder: indeo::indeo5::get_decoder },
#[cfg(feature="decoder_intel263")]
    DecoderInfo { name: "intel263", get_decoder: h263::intel263::get_decoder },
#[cfg(feature="decoder_realvideo1")]
    DecoderInfo { name: "realvideo1", get_decoder: h263::rv10::get_decoder },
#[cfg(feature="decoder_realvideo2")]
    DecoderInfo { name: "realvideo2", get_decoder: h263::rv20::get_decoder },
#[cfg(feature="decoder_realvideo3")]
    DecoderInfo { name: "realvideo3", get_decoder: real::rv30::get_decoder },
#[cfg(feature="decoder_realvideo4")]
    DecoderInfo { name: "realvideo4", get_decoder: real::rv40::get_decoder },
#[cfg(feature="decoder_realvideo6")]
    DecoderInfo { name: "realvideo6", get_decoder: real::rv60::get_decoder },

#[cfg(feature="decoder_pcm")]
    DecoderInfo { name: "pcm", get_decoder: pcm::get_decoder },
#[cfg(feature="decoder_imc")]
    DecoderInfo { name: "imc", get_decoder: indeo::imc::get_decoder_imc },
#[cfg(feature="decoder_imc")]
    DecoderInfo { name: "iac", get_decoder: indeo::imc::get_decoder_iac },
#[cfg(feature="decoder_realaudio144")]
    DecoderInfo { name: "ra14.4", get_decoder: real::ra144::get_decoder },
#[cfg(feature="decoder_realaudio288")]
    DecoderInfo { name: "ra28.8", get_decoder: real::ra288::get_decoder },
#[cfg(feature="decoder_sipro")]
    DecoderInfo { name: "sipro", get_decoder: sipro::get_decoder },
#[cfg(feature="decoder_ts102366")]
    DecoderInfo { name: "ac3", get_decoder: ts102366::get_decoder },
#[cfg(feature="decoder_cook")]
    DecoderInfo { name: "cook", get_decoder: real::cook::get_decoder },
#[cfg(feature="decoder_atrac3")]
    DecoderInfo { name: "atrac3", get_decoder: atrac3::get_decoder },
#[cfg(feature="decoder_aac")]
    DecoderInfo { name: "aac", get_decoder: aac::get_decoder },
#[cfg(feature="decoder_ralf")]
    DecoderInfo { name: "ralf", get_decoder: real::ralf::get_decoder },
];

pub fn find_decoder(name: &str) -> Option<fn () -> Box<NADecoder>> {
    for &dec in DECODERS {
        if dec.name == name {
            return Some(dec.get_decoder);
        }
    }
    None
}
Commit	Line	Data
c3e7a747 KS	1	use std::fmt;
	2	use std::ops::{Add, AddAssign, Sub, SubAssign};
	3
77d06de2	4	use frame::*;
88c03b61 KS	5	use std::rc::Rc;
88c03b61 KS	6	use std::cell::RefCell;
32007ad9	7	use std::mem;
77d06de2 KS	8	use io::byteio::ByteIOError;
	9	use io::bitreader::BitReaderError;
	10	use io::codebook::CodebookError;
	11
	12	#[derive(Debug,Clone,Copy,PartialEq)]
	13	#[allow(dead_code)]
	14	pub enum DecoderError {
6d3bb0b2	15	NoFrame,
e35062e7	16	AllocError,
503374e7	17	TryAgain,
77d06de2 KS	18	InvalidData,
	19	ShortData,
	20	MissingReference,
	21	NotImplemented,
	22	Bug,
	23	}
	24
cf64af13	25	pub type DecoderResult<T> = Result<T, DecoderError>;
77d06de2 KS	26
	27	impl From<ByteIOError> for DecoderError {
	28	fn from(_: ByteIOError) -> Self { DecoderError::ShortData }
	29	}
	30
	31	impl From<BitReaderError> for DecoderError {
	32	fn from(e: BitReaderError) -> Self {
	33	match e {
	34	BitReaderError::BitstreamEnd => DecoderError::ShortData,
	35	_ => DecoderError::InvalidData,
	36	}
	37	}
	38	}
	39
	40	impl From<CodebookError> for DecoderError {
	41	fn from(_: CodebookError) -> Self { DecoderError::InvalidData }
	42	}
	43
e35062e7 KS	44	impl From<AllocatorError> for DecoderError {
	45	fn from(_: AllocatorError) -> Self { DecoderError::AllocError }
	46	}
	47
cf64af13	48	macro_rules! validate {
2324f30b	49	($a:expr) => { if !$a { println!("check failed at {}:{}", file!(), line!()); return Err(DecoderError::InvalidData); } };
cf64af13 KS	50	}
cf64af13 KS	51
88c03b61 KS	52	#[allow(dead_code)]
88c03b61 KS	53	struct HAMShuffler {
22cb00db	54	lastframe: Option<NAVideoBuffer<u8>>,
88c03b61 KS	55	}
	56
	57	impl HAMShuffler {
	58	#[allow(dead_code)]
	59	fn new() -> Self { HAMShuffler { lastframe: None } }
	60	#[allow(dead_code)]
	61	fn clear(&mut self) { self.lastframe = None; }
	62	#[allow(dead_code)]
22cb00db KS	63	fn add_frame(&mut self, buf: NAVideoBuffer<u8>) {
22cb00db KS	64	self.lastframe = Some(buf);
88c03b61 KS	65	}
88c03b61 KS	66	#[allow(dead_code)]
22cb00db	67	fn clone_ref(&mut self) -> Option<NAVideoBuffer<u8>> {
3bd541c8	68	if let Some(ref mut frm) = self.lastframe {
22cb00db	69	let newfrm = frm.copy_buffer();
3bd541c8 KS	70	*frm = newfrm.clone();
3bd541c8 KS	71	Some(newfrm)
5c253468 KS	72	} else {
	73	None
	74	}
88c03b61 KS	75	}
88c03b61 KS	76	#[allow(dead_code)]
22cb00db	77	fn get_output_frame(&mut self) -> Option<NAVideoBuffer<u8>> {
88c03b61 KS	78	match self.lastframe {
	79	Some(ref frm) => Some(frm.clone()),
	80	None => None,
	81	}
	82	}
	83	}
	84
3f29a2a8 KS	85	#[allow(dead_code)]
	86	struct IPShuffler {
	87	lastframe: Option<NAVideoBuffer<u8>>,
	88	}
	89
	90	impl IPShuffler {
	91	#[allow(dead_code)]
	92	fn new() -> Self { IPShuffler { lastframe: None } }
	93	#[allow(dead_code)]
	94	fn clear(&mut self) { self.lastframe = None; }
	95	#[allow(dead_code)]
	96	fn add_frame(&mut self, buf: NAVideoBuffer<u8>) {
	97	self.lastframe = Some(buf);
	98	}
	99	#[allow(dead_code)]
	100	fn get_ref(&mut self) -> Option<NAVideoBuffer<u8>> {
	101	if let Some(ref frm) = self.lastframe {
	102	Some(frm.clone())
	103	} else {
	104	None
	105	}
32007ad9 KS	106	}
	107	}
	108
	109	#[allow(dead_code)]
	110	struct IPBShuffler {
	111	lastframe: Option<NAVideoBuffer<u8>>,
	112	nextframe: Option<NAVideoBuffer<u8>>,
	113	}
	114
	115	impl IPBShuffler {
	116	#[allow(dead_code)]
	117	fn new() -> Self { IPBShuffler { lastframe: None, nextframe: None } }
	118	#[allow(dead_code)]
	119	fn clear(&mut self) { self.lastframe = None; self.nextframe = None; }
	120	#[allow(dead_code)]
	121	fn add_frame(&mut self, buf: NAVideoBuffer<u8>) {
	122	mem::swap(&mut self.lastframe, &mut self.nextframe);
	123	self.lastframe = Some(buf);
	124	}
	125	#[allow(dead_code)]
	126	fn get_lastref(&mut self) -> Option<NAVideoBuffer<u8>> {
	127	if let Some(ref frm) = self.lastframe {
	128	Some(frm.clone())
	129	} else {
	130	None
	131	}
	132	}
	133	#[allow(dead_code)]
	134	fn get_nextref(&mut self) -> Option<NAVideoBuffer<u8>> {
	135	if let Some(ref frm) = self.nextframe {
	136	Some(frm.clone())
	137	} else {
	138	None
	139	}
3f29a2a8	140	}
3c8c667d KS	141	#[allow(dead_code)]
	142	fn get_b_fwdref(&mut self) -> Option<NAVideoBuffer<u8>> {
	143	if let Some(ref frm) = self.nextframe {
	144	Some(frm.clone())
	145	} else {
	146	None
	147	}
	148	}
	149	#[allow(dead_code)]
	150	fn get_b_bwdref(&mut self) -> Option<NAVideoBuffer<u8>> {
	151	if let Some(ref frm) = self.lastframe {
	152	Some(frm.clone())
	153	} else {
	154	None
	155	}
	156	}
3f29a2a8 KS	157	}
3f29a2a8 KS	158
52aad9fe	159	#[derive(Debug,Clone,Copy,PartialEq)]
c3e7a747 KS	160	pub struct MV {
	161	pub x: i16,
	162	pub y: i16,
	163	}
	164
	165	impl MV {
	166	pub fn new(x: i16, y: i16) -> Self { MV{ x: x, y: y } }
	167	pub fn pred(a: MV, b: MV, c: MV) -> Self {
	168	let x;
	169	if a.x < b.x {
	170	if b.x < c.x {
	171	x = b.x;
	172	} else {
	173	if a.x < c.x { x = c.x; } else { x = a.x; }
	174	}
	175	} else {
	176	if b.x < c.x {
	177	if a.x < c.x { x = a.x; } else { x = c.x; }
	178	} else {
	179	x = b.x;
	180	}
	181	}
	182	let y;
	183	if a.y < b.y {
	184	if b.y < c.y {
	185	y = b.y;
	186	} else {
	187	if a.y < c.y { y = c.y; } else { y = a.y; }
	188	}
	189	} else {
	190	if b.y < c.y {
	191	if a.y < c.y { y = a.y; } else { y = c.y; }
	192	} else {
	193	y = b.y;
	194	}
	195	}
	196	MV { x: x, y: y }
	197	}
	198	}
	199
	200	pub const ZERO_MV: MV = MV { x: 0, y: 0 };
	201
	202	impl Add for MV {
	203	type Output = MV;
	204	fn add(self, other: MV) -> MV { MV { x: self.x + other.x, y: self.y + other.y } }
	205	}
	206
	207	impl AddAssign for MV {
	208	fn add_assign(&mut self, other: MV) { self.x += other.x; self.y += other.y; }
	209	}
	210
	211	impl Sub for MV {
	212	type Output = MV;
	213	fn sub(self, other: MV) -> MV { MV { x: self.x - other.x, y: self.y - other.y } }
	214	}
	215
	216	impl SubAssign for MV {
	217	fn sub_assign(&mut self, other: MV) { self.x -= other.x; self.y -= other.y; }
	218	}
	219
	220	impl fmt::Display for MV {
	221	fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
	222	write!(f, "{},{}", self.x, self.y)
	223	}
224	}
225
226
77d06de2 KS	227	pub trait NADecoder {
77d06de2 KS	228	fn init(&mut self, info: Rc<NACodecInfo>) -> DecoderResult<()>;
88c03b61	229	fn decode(&mut self, pkt: &NAPacket) -> DecoderResult<NAFrameRef>;
77d06de2 KS	230	}
77d06de2 KS	231
70259941	232	#[derive(Clone,Copy)]
2a4130ba	233	pub struct DecoderInfo {
70259941 KS	234	name: &'static str,
	235	get_decoder: fn () -> Box<NADecoder>,
	236	}
	237
47527732	238	#[cfg(any(feature="h263", feature="decoder_realvideo3", feature="decoder_realvideo4"))]
88c58b1b KS	239	mod blockdsp;
88c58b1b KS	240
750b299c KS	241	#[cfg(feature="decoder_clearvideo")]
750b299c KS	242	mod clearvideo;
e120f8fd KS	243	#[cfg(feature="decoder_gdvvid")]
e120f8fd KS	244	mod gremlinvideo;
01c971c5	245	#[cfg(any(feature="decoder_indeo2", feature="decoder_indeo3", feature="decoder_indeo4", feature="decoder_indeo5", feature="decoder_imc"))]
88c58b1b KS	246	mod indeo;
	247	#[cfg(feature="h263")]
	248	mod h263;
ae58cfa5	249	#[cfg(any(feature="decoder_realvideo3", feature="decoder_realvideo4", feature="decoder_realvideo6", feature="decoder_realaudio144", feature="decoder_realaudio288", feature="decoder_cook", feature="decoder_ralf"))]
47527732	250	mod real;
cf64af13	251
5a932f64 KS	252	#[cfg(feature="decoder_aac")]
5a932f64 KS	253	mod aac;
aab478c1 KS	254	#[cfg(feature="decoder_atrac3")]
aab478c1 KS	255	mod atrac3;
3f29a2a8 KS	256	#[cfg(feature="decoder_pcm")]
3f29a2a8 KS	257	mod pcm;
f4bb5ccb KS	258	#[cfg(feature="decoder_sipro")]
f4bb5ccb KS	259	mod sipro;
16dd4f44 KS	260	#[cfg(feature="decoder_ts102366")]
16dd4f44 KS	261	mod ts102366;
3f29a2a8	262
2a4130ba	263	const DECODERS: &[DecoderInfo] = &[
750b299c KS	264	#[cfg(feature="decoder_clearvideo")]
	265	DecoderInfo { name: "clearvideo", get_decoder: clearvideo::get_decoder },
	266	#[cfg(feature="decoder_clearvideo")]
	267	DecoderInfo { name: "clearvideo_rm", get_decoder: clearvideo::get_decoder_rm },
e120f8fd KS	268	#[cfg(feature="decoder_gdvvid")]
e120f8fd KS	269	DecoderInfo { name: "gdv-video", get_decoder: gremlinvideo::get_decoder },
70259941	270	#[cfg(feature="decoder_indeo2")]
88c58b1b	271	DecoderInfo { name: "indeo2", get_decoder: indeo::indeo2::get_decoder },
3f29a2a8	272	#[cfg(feature="decoder_indeo3")]
88c58b1b	273	DecoderInfo { name: "indeo3", get_decoder: indeo::indeo3::get_decoder },
01c971c5 KS	274	#[cfg(feature="decoder_indeo4")]
	275	DecoderInfo { name: "indeo4", get_decoder: indeo::indeo4::get_decoder },
	276	#[cfg(feature="decoder_indeo5")]
	277	DecoderInfo { name: "indeo5", get_decoder: indeo::indeo5::get_decoder },
88c58b1b KS	278	#[cfg(feature="decoder_intel263")]
88c58b1b KS	279	DecoderInfo { name: "intel263", get_decoder: h263::intel263::get_decoder },
2324f30b KS	280	#[cfg(feature="decoder_realvideo1")]
2324f30b KS	281	DecoderInfo { name: "realvideo1", get_decoder: h263::rv10::get_decoder },
be91b1c3 KS	282	#[cfg(feature="decoder_realvideo2")]
be91b1c3 KS	283	DecoderInfo { name: "realvideo2", get_decoder: h263::rv20::get_decoder },
47527732 KS	284	#[cfg(feature="decoder_realvideo3")]
	285	DecoderInfo { name: "realvideo3", get_decoder: real::rv30::get_decoder },
	286	#[cfg(feature="decoder_realvideo4")]
	287	DecoderInfo { name: "realvideo4", get_decoder: real::rv40::get_decoder },
	288	#[cfg(feature="decoder_realvideo6")]
	289	DecoderInfo { name: "realvideo6", get_decoder: real::rv60::get_decoder },
cf64af13	290
3234da61 KS	291	#[cfg(feature="decoder_pcm")]
3234da61 KS	292	DecoderInfo { name: "pcm", get_decoder: pcm::get_decoder },
e35062e7 KS	293	#[cfg(feature="decoder_imc")]
	294	DecoderInfo { name: "imc", get_decoder: indeo::imc::get_decoder_imc },
	295	#[cfg(feature="decoder_imc")]
	296	DecoderInfo { name: "iac", get_decoder: indeo::imc::get_decoder_iac },
37d2275e KS	297	#[cfg(feature="decoder_realaudio144")]
	298	DecoderInfo { name: "ra14.4", get_decoder: real::ra144::get_decoder },
	299	#[cfg(feature="decoder_realaudio288")]
	300	DecoderInfo { name: "ra28.8", get_decoder: real::ra288::get_decoder },
f4bb5ccb KS	301	#[cfg(feature="decoder_sipro")]
f4bb5ccb KS	302	DecoderInfo { name: "sipro", get_decoder: sipro::get_decoder },
16dd4f44 KS	303	#[cfg(feature="decoder_ts102366")]
16dd4f44 KS	304	DecoderInfo { name: "ac3", get_decoder: ts102366::get_decoder },
594ca5ca KS	305	#[cfg(feature="decoder_cook")]
594ca5ca KS	306	DecoderInfo { name: "cook", get_decoder: real::cook::get_decoder },
aab478c1 KS	307	#[cfg(feature="decoder_atrac3")]
aab478c1 KS	308	DecoderInfo { name: "atrac3", get_decoder: atrac3::get_decoder },
5a932f64 KS	309	#[cfg(feature="decoder_aac")]
5a932f64 KS	310	DecoderInfo { name: "aac", get_decoder: aac::get_decoder },
ae58cfa5 KS	311	#[cfg(feature="decoder_ralf")]
ae58cfa5 KS	312	DecoderInfo { name: "ralf", get_decoder: real::ralf::get_decoder },
70259941 KS	313	];
	314
	315	pub fn find_decoder(name: &str) -> Option<fn () -> Box<NADecoder>> {
	316	for &dec in DECODERS {
	317	if dec.name == name {
	318	return Some(dec.get_decoder);
	319	}
	320	}
	321	None
	322	}