[nihav.git] / nihav-core / src / scale / mod.rs

use crate::frame::*;

mod kernel;

mod colorcvt;
mod repack;
mod scale;

#[derive(Clone,Copy,PartialEq)]
pub struct ScaleInfo {
    pub fmt:    NAPixelFormaton,
    pub width:  usize,
    pub height: usize,
}

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

#[derive(Debug,Clone,Copy,PartialEq)]
#[allow(dead_code)]
pub enum ScaleError {
    NoFrame,
    AllocError,
    InvalidArgument,
    NotImplemented,
    Bug,
}

pub type ScaleResult<T> = Result<T, ScaleError>;

/*trait Kernel {
    fn init(&mut self, in_fmt: &ScaleInfo, dest_fmt: &ScaleInfo) -> ScaleResult<NABufferType>;
    fn process(&mut self, pic_in: &NABufferType, pic_out: &mut NABufferType);
}*/

struct KernelDesc {
    name:       &'static str,
    create:     fn () -> Box<dyn kernel::Kernel>,
}

impl KernelDesc {
    fn find(name: &str) -> ScaleResult<Box<dyn kernel::Kernel>> {
        for kern in KERNELS.iter() {
            if kern.name == name {
                return Ok((kern.create)());
            }
        }
        Err(ScaleError::InvalidArgument)
    }
}

const KERNELS: &[KernelDesc] = &[
    KernelDesc { name: "pack",          create: repack::create_pack },
    KernelDesc { name: "unpack",        create: repack::create_unpack },
    KernelDesc { name: "depal",         create: repack::create_depal },
    KernelDesc { name: "scale",         create: scale::create_scale },
    KernelDesc { name: "rgb_to_yuv",    create: colorcvt::create_rgb2yuv },
    KernelDesc { name: "yuv_to_rgb",    create: colorcvt::create_yuv2rgb },
];

struct Stage {
    fmt_out:    ScaleInfo,
    tmp_pic:    NABufferType,
    next:       Option<Box<Stage>>,
    worker:     Box<dyn kernel::Kernel>,
}

pub fn get_scale_fmt_from_pic(pic: &NABufferType) -> ScaleInfo {
    let info = pic.get_video_info().unwrap();
    ScaleInfo { fmt: info.get_format(), width: info.get_width(), height: info.get_height() }
}

impl Stage {
    fn new(name: &str, in_fmt: &ScaleInfo, dest_fmt: &ScaleInfo) -> ScaleResult<Self> {
        let mut worker = KernelDesc::find(name)?;
        let tmp_pic = worker.init(in_fmt, dest_fmt)?;
        let fmt_out = get_scale_fmt_from_pic(&tmp_pic);
        Ok(Self { fmt_out, tmp_pic, next: None, worker })
    }
    fn add(&mut self, new: Stage) {
        if let Some(ref mut next) = self.next {
            next.add(new);
        } else {
            self.next = Some(Box::new(new));
        }
    }
    fn process(&mut self, pic_in: &NABufferType, pic_out: &mut NABufferType) -> ScaleResult<()> {
        if let Some(ref mut nextstage) = self.next {
            self.worker.process(pic_in, &mut self.tmp_pic);
            nextstage.process(&self.tmp_pic, pic_out)?;
        } else {
            self.worker.process(pic_in, pic_out);
        }
        Ok(())
    }
    fn drop_last_tmp(&mut self) {
        if let Some(ref mut nextstage) = self.next {
            nextstage.drop_last_tmp();
        } else {
            self.tmp_pic = NABufferType::None;
        }
    }
}

pub struct NAScale {
    fmt_in:         ScaleInfo,
    fmt_out:        ScaleInfo,
    just_convert:   bool,
    pipeline:       Option<Stage>,
}

fn check_format(in_fmt: NAVideoInfo, ref_fmt: &ScaleInfo, just_convert: bool) -> ScaleResult<()> {
    if in_fmt.get_format() != ref_fmt.fmt { return Err(ScaleError::InvalidArgument); }
    if !just_convert && (in_fmt.get_width() != ref_fmt.width || in_fmt.get_height() != ref_fmt.height) {
        return Err(ScaleError::InvalidArgument);
    }
    Ok(())
}

fn copy(pic_in: &NABufferType, pic_out: &mut NABufferType)
{
    if let (Some(ref sbuf), Some(ref mut dbuf)) = (pic_in.get_vbuf(), pic_out.get_vbuf()) {
        let mut same = true;
        let num_components = sbuf.get_info().get_format().get_num_comp();
        for i in 0..num_components {
            if sbuf.get_stride(i) != dbuf.get_stride(i) {
                same = false;
                break;
            }
            if sbuf.get_offset(i) != dbuf.get_offset(i) {
                same = false;
                break;
            }
        }
        if same {
            let sdata = sbuf.get_data();
            let ddata = dbuf.get_data_mut().unwrap();
            ddata.copy_from_slice(&sdata[0..]);
        } else {
            let sdata = sbuf.get_data();
            for comp in 0..num_components {
                let (_, h) = sbuf.get_dimensions(comp);
                let src = &sdata[sbuf.get_offset(comp)..];
                let sstride = sbuf.get_stride(comp);
                let doff = dbuf.get_offset(comp);
                let dstride = dbuf.get_stride(comp);
                let ddata = dbuf.get_data_mut().unwrap();
                let dst = &mut ddata[doff..];
                let copy_size = sstride.min(dstride);
                for (dline, sline) in dst.chunks_exact_mut(dstride).take(h).zip(src.chunks_exact(sstride)) {
                    (&mut dline[..copy_size]).copy_from_slice(&sline[..copy_size]);
                }
            }
        }
    } else {
        unimplemented!();
    }
}

macro_rules! add_stage {
    ($head:expr, $new:expr) => {
        if let Some(ref mut h) = $head {
            h.add($new);
        } else {
            $head = Some($new);
        }
    };
}
fn is_better_fmt(a: &ScaleInfo, b: &ScaleInfo) -> bool {
    if (a.width >= b.width) && (a.height >= b.height) {
        return true;
    }
    if a.fmt.get_max_depth() > b.fmt.get_max_depth() {
        return true;
    }
    if a.fmt.get_max_subsampling() < b.fmt.get_max_subsampling() {
        return true;
    }
    false
}
fn build_pipeline(ifmt: &ScaleInfo, ofmt: &ScaleInfo, just_convert: bool) -> ScaleResult<Option<Stage>> {
    let inname  = ifmt.fmt.get_model().get_short_name();
    let outname = ofmt.fmt.get_model().get_short_name();

println!("convert {} -> {}", ifmt, ofmt);
    let needs_scale = if (ofmt.fmt.get_max_subsampling() > 0) &&
        (ofmt.fmt.get_max_subsampling() != ifmt.fmt.get_max_subsampling()) {
            true
        } else {
            !just_convert
        };
    let needs_unpack = !ifmt.fmt.is_unpacked();
    let needs_pack = !ofmt.fmt.is_unpacked();
    let needs_convert = inname != outname;
    let scale_before_cvt = is_better_fmt(&ifmt, &ofmt) && needs_convert
                           && (ofmt.fmt.get_max_subsampling() == 0);
//todo stages for model and gamma conversion

    let mut stages: Option<Stage> = None;
    let mut cur_fmt = *ifmt;

    if needs_unpack {
println!("[adding unpack]");
        let new_stage = if !cur_fmt.fmt.is_paletted() {
                Stage::new("unpack", &cur_fmt, &ofmt)?
            } else {
                Stage::new("depal", &cur_fmt, &ofmt)?
            };
        cur_fmt = new_stage.fmt_out;
        add_stage!(stages, new_stage);
    }
    if needs_scale && scale_before_cvt {
println!("[adding scale]");
        let new_stage = Stage::new("scale", &cur_fmt, &ofmt)?;
        cur_fmt = new_stage.fmt_out;
        add_stage!(stages, new_stage);
    }
    if needs_convert {
println!("[adding convert]");
        let cvtname = format!("{}_to_{}", inname, outname);
println!("[{}]", cvtname);
        let new_stage = Stage::new(&cvtname, &cur_fmt, &ofmt)?;
//todo if fails try converting via RGB or YUV
        cur_fmt = new_stage.fmt_out;
        add_stage!(stages, new_stage);
//todo alpha plane copy/add
    }
    if needs_scale && !scale_before_cvt {
println!("[adding scale]");
        let new_stage = Stage::new("scale", &cur_fmt, &ofmt)?;
        cur_fmt = new_stage.fmt_out;
        add_stage!(stages, new_stage);
    }
//todo flip if needed
    if needs_pack {
println!("[adding pack]");
        let new_stage = Stage::new("pack", &cur_fmt, &ofmt)?;
        //cur_fmt = new_stage.fmt_out;
        add_stage!(stages, new_stage);
    }

    if let Some(ref mut head) = stages {
        head.drop_last_tmp();
    }
    
    Ok(stages)
}

impl NAScale {
    pub fn new(fmt_in: ScaleInfo, fmt_out: ScaleInfo) -> ScaleResult<Self> {
        let pipeline;
        let just_convert = (fmt_in.width == fmt_out.width) && (fmt_in.height == fmt_out.height);
        if fmt_in != fmt_out {
            pipeline = build_pipeline(&fmt_in, &fmt_out, just_convert)?;
        } else {
            pipeline = None;
        }
        Ok(Self { fmt_in, fmt_out, just_convert, pipeline })
    }
    pub fn needs_processing(&self) -> bool { self.pipeline.is_some() }
    pub fn get_in_fmt(&self) -> ScaleInfo { self.fmt_in }
    pub fn get_out_fmt(&self) -> ScaleInfo { self.fmt_out }
    pub fn convert(&mut self, pic_in: &NABufferType, pic_out: &mut NABufferType) -> ScaleResult<()> {
        let in_info  = pic_in.get_video_info();
        let out_info = pic_out.get_video_info();
        if in_info.is_none() || out_info.is_none() { return Err(ScaleError::InvalidArgument); }
        let in_info  = in_info.unwrap();
        let out_info = out_info.unwrap();
        if self.just_convert &&
                (in_info.get_width() != out_info.get_width() || in_info.get_height() != out_info.get_height()) {
            return Err(ScaleError::InvalidArgument);
        }
        check_format(in_info,  &self.fmt_in,  self.just_convert)?;
        check_format(out_info, &self.fmt_out, self.just_convert)?;
        if let Some(ref mut pipe) = self.pipeline {
            pipe.process(pic_in, pic_out)
        } else {
            copy(pic_in, pic_out);
            Ok(())
        }
    }
}

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

    fn fill_pic(pic: &mut NABufferType, val: u8) {
        if let Some(ref mut buf) = pic.get_vbuf() {
            let data = buf.get_data_mut().unwrap();
            for el in data.iter_mut() { *el = val; }
        } else if let Some(ref mut buf) = pic.get_vbuf16() {
            let data = buf.get_data_mut().unwrap();
            for el in data.iter_mut() { *el = val as u16; }
        } else if let Some(ref mut buf) = pic.get_vbuf32() {
            let data = buf.get_data_mut().unwrap();
            for el in data.iter_mut() { *el = (val as u32) * 0x01010101; }
        }
    }
    #[test]
    fn test_convert() {
        let mut in_pic = alloc_video_buffer(NAVideoInfo::new(1, 1, false, RGB565_FORMAT), 3).unwrap();
        fill_pic(&mut in_pic, 42);
        let mut out_pic = alloc_video_buffer(NAVideoInfo::new(1, 1, false, RGB24_FORMAT), 3).unwrap();
        fill_pic(&mut out_pic, 0);
        let ifmt = get_scale_fmt_from_pic(&in_pic);
        let ofmt = get_scale_fmt_from_pic(&out_pic);
        let mut scaler = NAScale::new(ifmt, ofmt).unwrap();
        scaler.convert(&in_pic, &mut out_pic).unwrap();
        let obuf = out_pic.get_vbuf().unwrap();
        let odata = obuf.get_data();
        assert_eq!(odata[0], 0x0);
        assert_eq!(odata[1], 0x4);
        assert_eq!(odata[2], 0x52);

        let mut in_pic = alloc_video_buffer(NAVideoInfo::new(4, 4, false, RGB24_FORMAT), 3).unwrap();
        fill_pic(&mut in_pic, 42);
        let mut out_pic = alloc_video_buffer(NAVideoInfo::new(4, 4, false, YUV420_FORMAT), 3).unwrap();
        fill_pic(&mut out_pic, 0);
        let ifmt = get_scale_fmt_from_pic(&in_pic);
        let ofmt = get_scale_fmt_from_pic(&out_pic);
        let mut scaler = NAScale::new(ifmt, ofmt).unwrap();
        scaler.convert(&in_pic, &mut out_pic).unwrap();
        let obuf = out_pic.get_vbuf().unwrap();
        let yoff = obuf.get_offset(0);
        let uoff = obuf.get_offset(1);
        let voff = obuf.get_offset(2);
        let odata = obuf.get_data();
        assert_eq!(odata[yoff], 42);
        assert!(((odata[uoff] ^ 0x80) as i8).abs() <= 1);
        assert!(((odata[voff] ^ 0x80) as i8).abs() <= 1);
        let mut scaler = NAScale::new(ofmt, ifmt).unwrap();
        scaler.convert(&out_pic, &mut in_pic).unwrap();
        let obuf = in_pic.get_vbuf().unwrap();
        let odata = obuf.get_data();
        assert_eq!(odata[0], 42);
    }
    #[test]
    fn test_scale() {
        let mut in_pic = alloc_video_buffer(NAVideoInfo::new(2, 2, false, RGB565_FORMAT), 3).unwrap();
        fill_pic(&mut in_pic, 42);
        let mut out_pic = alloc_video_buffer(NAVideoInfo::new(3, 3, false, RGB565_FORMAT), 3).unwrap();
        fill_pic(&mut out_pic, 0);
        let ifmt = get_scale_fmt_from_pic(&in_pic);
        let ofmt = get_scale_fmt_from_pic(&out_pic);
        let mut scaler = NAScale::new(ifmt, ofmt).unwrap();
        scaler.convert(&in_pic, &mut out_pic).unwrap();
        let obuf = out_pic.get_vbuf16().unwrap();
        let odata = obuf.get_data();
        assert_eq!(odata[0], 42);
    }
    #[test]
    fn test_scale_and_convert() {
        let mut in_pic = alloc_video_buffer(NAVideoInfo::new(7, 3, false, RGB565_FORMAT), 3).unwrap();
        fill_pic(&mut in_pic, 42);
        let mut out_pic = alloc_video_buffer(NAVideoInfo::new(4, 4, false, YUV420_FORMAT), 3).unwrap();
        fill_pic(&mut out_pic, 0);
        let ifmt = get_scale_fmt_from_pic(&in_pic);
        let ofmt = get_scale_fmt_from_pic(&out_pic);
        let mut scaler = NAScale::new(ifmt, ofmt).unwrap();
        scaler.convert(&in_pic, &mut out_pic).unwrap();
        let obuf = out_pic.get_vbuf().unwrap();
        let yoff = obuf.get_offset(0);
        let uoff = obuf.get_offset(1);
        let voff = obuf.get_offset(2);
        let odata = obuf.get_data();
        assert_eq!(odata[yoff], 28);
        assert_eq!(odata[uoff], 154);
        assert_eq!(odata[voff], 103);
    }
}
Commit	Line	Data
03accf76 KS	1	use crate::frame::*;
	2
	3	mod kernel;
	4
	5	mod colorcvt;
	6	mod repack;
	7	mod scale;
	8
	9	#[derive(Clone,Copy,PartialEq)]
	10	pub struct ScaleInfo {
	11	pub fmt: NAPixelFormaton,
	12	pub width: usize,
	13	pub height: usize,
	14	}
	15
	16	impl std::fmt::Display for ScaleInfo {
	17	fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
	18	write!(f, "({}x{}, {})", self.width, self.height, self.fmt)
	19	}
	20	}
	21
	22	#[derive(Debug,Clone,Copy,PartialEq)]
	23	#[allow(dead_code)]
	24	pub enum ScaleError {
	25	NoFrame,
	26	AllocError,
	27	InvalidArgument,
	28	NotImplemented,
	29	Bug,
	30	}
	31
	32	pub type ScaleResult<T> = Result<T, ScaleError>;
	33
	34	/*trait Kernel {
	35	fn init(&mut self, in_fmt: &ScaleInfo, dest_fmt: &ScaleInfo) -> ScaleResult<NABufferType>;
	36	fn process(&mut self, pic_in: &NABufferType, pic_out: &mut NABufferType);
	37	}*/
	38
	39	struct KernelDesc {
	40	name: &'static str,
6011e201	41	create: fn () -> Box<dyn kernel::Kernel>,
03accf76 KS	42	}
	43
	44	impl KernelDesc {
6011e201	45	fn find(name: &str) -> ScaleResult<Box<dyn kernel::Kernel>> {
03accf76 KS	46	for kern in KERNELS.iter() {
	47	if kern.name == name {
	48	return Ok((kern.create)());
	49	}
	50	}
	51	Err(ScaleError::InvalidArgument)
	52	}
	53	}
	54
	55	const KERNELS: &[KernelDesc] = &[
	56	KernelDesc { name: "pack", create: repack::create_pack },
	57	KernelDesc { name: "unpack", create: repack::create_unpack },
	58	KernelDesc { name: "depal", create: repack::create_depal },
	59	KernelDesc { name: "scale", create: scale::create_scale },
	60	KernelDesc { name: "rgb_to_yuv", create: colorcvt::create_rgb2yuv },
	61	KernelDesc { name: "yuv_to_rgb", create: colorcvt::create_yuv2rgb },
	62	];
	63
	64	struct Stage {
	65	fmt_out: ScaleInfo,
	66	tmp_pic: NABufferType,
	67	next: Option<Box<Stage>>,
6011e201	68	worker: Box<dyn kernel::Kernel>,
03accf76 KS	69	}
	70
	71	pub fn get_scale_fmt_from_pic(pic: &NABufferType) -> ScaleInfo {
	72	let info = pic.get_video_info().unwrap();
	73	ScaleInfo { fmt: info.get_format(), width: info.get_width(), height: info.get_height() }
	74	}
	75
	76	impl Stage {
	77	fn new(name: &str, in_fmt: &ScaleInfo, dest_fmt: &ScaleInfo) -> ScaleResult<Self> {
	78	let mut worker = KernelDesc::find(name)?;
	79	let tmp_pic = worker.init(in_fmt, dest_fmt)?;
	80	let fmt_out = get_scale_fmt_from_pic(&tmp_pic);
	81	Ok(Self { fmt_out, tmp_pic, next: None, worker })
	82	}
	83	fn add(&mut self, new: Stage) {
	84	if let Some(ref mut next) = self.next {
	85	next.add(new);
	86	} else {
	87	self.next = Some(Box::new(new));
	88	}
	89	}
	90	fn process(&mut self, pic_in: &NABufferType, pic_out: &mut NABufferType) -> ScaleResult<()> {
	91	if let Some(ref mut nextstage) = self.next {
	92	self.worker.process(pic_in, &mut self.tmp_pic);
	93	nextstage.process(&self.tmp_pic, pic_out)?;
	94	} else {
	95	self.worker.process(pic_in, pic_out);
	96	}
	97	Ok(())
	98	}
	99	fn drop_last_tmp(&mut self) {
	100	if let Some(ref mut nextstage) = self.next {
	101	nextstage.drop_last_tmp();
	102	} else {
	103	self.tmp_pic = NABufferType::None;
	104	}
	105	}
	106	}
	107
	108	pub struct NAScale {
	109	fmt_in: ScaleInfo,
	110	fmt_out: ScaleInfo,
	111	just_convert: bool,
	112	pipeline: Option<Stage>,
	113	}
	114
	115	fn check_format(in_fmt: NAVideoInfo, ref_fmt: &ScaleInfo, just_convert: bool) -> ScaleResult<()> {
	116	if in_fmt.get_format() != ref_fmt.fmt { return Err(ScaleError::InvalidArgument); }
	117	if !just_convert && (in_fmt.get_width() != ref_fmt.width \|\| in_fmt.get_height() != ref_fmt.height) {
	118	return Err(ScaleError::InvalidArgument);
	119	}
	120	Ok(())
	121	}
	122
	123	fn copy(pic_in: &NABufferType, pic_out: &mut NABufferType)
	124	{
	125	if let (Some(ref sbuf), Some(ref mut dbuf)) = (pic_in.get_vbuf(), pic_out.get_vbuf()) {
79ec1d51 KS	126	let mut same = true;
	127	let num_components = sbuf.get_info().get_format().get_num_comp();
	128	for i in 0..num_components {
	129	if sbuf.get_stride(i) != dbuf.get_stride(i) {
	130	same = false;
	131	break;
	132	}
	133	if sbuf.get_offset(i) != dbuf.get_offset(i) {
	134	same = false;
	135	break;
	136	}
	137	}
	138	if same {
	139	let sdata = sbuf.get_data();
	140	let ddata = dbuf.get_data_mut().unwrap();
	141	ddata.copy_from_slice(&sdata[0..]);
	142	} else {
	143	let sdata = sbuf.get_data();
	144	for comp in 0..num_components {
	145	let (_, h) = sbuf.get_dimensions(comp);
	146	let src = &sdata[sbuf.get_offset(comp)..];
	147	let sstride = sbuf.get_stride(comp);
	148	let doff = dbuf.get_offset(comp);
	149	let dstride = dbuf.get_stride(comp);
	150	let ddata = dbuf.get_data_mut().unwrap();
	151	let dst = &mut ddata[doff..];
	152	let copy_size = sstride.min(dstride);
	153	for (dline, sline) in dst.chunks_exact_mut(dstride).take(h).zip(src.chunks_exact(sstride)) {
	154	(&mut dline[..copy_size]).copy_from_slice(&sline[..copy_size]);
	155	}
	156	}
	157	}
03accf76 KS	158	} else {
	159	unimplemented!();
	160	}
	161	}
	162
	163	macro_rules! add_stage {
	164	($head:expr, $new:expr) => {
	165	if let Some(ref mut h) = $head {
	166	h.add($new);
	167	} else {
	168	$head = Some($new);
	169	}
	170	};
	171	}
	172	fn is_better_fmt(a: &ScaleInfo, b: &ScaleInfo) -> bool {
	173	if (a.width >= b.width) && (a.height >= b.height) {
	174	return true;
	175	}
	176	if a.fmt.get_max_depth() > b.fmt.get_max_depth() {
	177	return true;
	178	}
	179	if a.fmt.get_max_subsampling() < b.fmt.get_max_subsampling() {
	180	return true;
	181	}
	182	false
	183	}
	184	fn build_pipeline(ifmt: &ScaleInfo, ofmt: &ScaleInfo, just_convert: bool) -> ScaleResult<Option<Stage>> {
	185	let inname = ifmt.fmt.get_model().get_short_name();
	186	let outname = ofmt.fmt.get_model().get_short_name();
	187
	188	println!("convert {} -> {}", ifmt, ofmt);
e243ceb4	189	let needs_scale = if (ofmt.fmt.get_max_subsampling() > 0) &&
03accf76	190	(ofmt.fmt.get_max_subsampling() != ifmt.fmt.get_max_subsampling()) {
e243ceb4 KS	191	true
	192	} else {
	193	!just_convert
	194	};
e9d8cce7	195	let needs_unpack = !ifmt.fmt.is_unpacked();
03accf76	196	let needs_pack = !ofmt.fmt.is_unpacked();
e243ceb4	197	let needs_convert = inname != outname;
03accf76 KS	198	let scale_before_cvt = is_better_fmt(&ifmt, &ofmt) && needs_convert
	199	&& (ofmt.fmt.get_max_subsampling() == 0);
	200	//todo stages for model and gamma conversion
	201
	202	let mut stages: Option<Stage> = None;
	203	let mut cur_fmt = *ifmt;
	204
	205	if needs_unpack {
	206	println!("[adding unpack]");
e243ceb4 KS	207	let new_stage = if !cur_fmt.fmt.is_paletted() {
	208	Stage::new("unpack", &cur_fmt, &ofmt)?
	209	} else {
	210	Stage::new("depal", &cur_fmt, &ofmt)?
	211	};
03accf76 KS	212	cur_fmt = new_stage.fmt_out;
	213	add_stage!(stages, new_stage);
	214	}
	215	if needs_scale && scale_before_cvt {
	216	println!("[adding scale]");
	217	let new_stage = Stage::new("scale", &cur_fmt, &ofmt)?;
	218	cur_fmt = new_stage.fmt_out;
	219	add_stage!(stages, new_stage);
	220	}
	221	if needs_convert {
	222	println!("[adding convert]");
	223	let cvtname = format!("{}_to_{}", inname, outname);
	224	println!("[{}]", cvtname);
	225	let new_stage = Stage::new(&cvtname, &cur_fmt, &ofmt)?;
	226	//todo if fails try converting via RGB or YUV
	227	cur_fmt = new_stage.fmt_out;
	228	add_stage!(stages, new_stage);
	229	//todo alpha plane copy/add
	230	}
	231	if needs_scale && !scale_before_cvt {
	232	println!("[adding scale]");
	233	let new_stage = Stage::new("scale", &cur_fmt, &ofmt)?;
	234	cur_fmt = new_stage.fmt_out;
	235	add_stage!(stages, new_stage);
	236	}
	237	//todo flip if needed
	238	if needs_pack {
	239	println!("[adding pack]");
	240	let new_stage = Stage::new("pack", &cur_fmt, &ofmt)?;
	241	//cur_fmt = new_stage.fmt_out;
	242	add_stage!(stages, new_stage);
	243	}
	244
	245	if let Some(ref mut head) = stages {
	246	head.drop_last_tmp();
	247	}
	248
	249	Ok(stages)
	250	}
	251
	252	impl NAScale {
	253	pub fn new(fmt_in: ScaleInfo, fmt_out: ScaleInfo) -> ScaleResult<Self> {
	254	let pipeline;
	255	let just_convert = (fmt_in.width == fmt_out.width) && (fmt_in.height == fmt_out.height);
	256	if fmt_in != fmt_out {
	257	pipeline = build_pipeline(&fmt_in, &fmt_out, just_convert)?;
	258	} else {
	259	pipeline = None;
	260	}
	261	Ok(Self { fmt_in, fmt_out, just_convert, pipeline })
	262	}
	263	pub fn needs_processing(&self) -> bool { self.pipeline.is_some() }
	264	pub fn get_in_fmt(&self) -> ScaleInfo { self.fmt_in }
	265	pub fn get_out_fmt(&self) -> ScaleInfo { self.fmt_out }
	266	pub fn convert(&mut self, pic_in: &NABufferType, pic_out: &mut NABufferType) -> ScaleResult<()> {
	267	let in_info = pic_in.get_video_info();
	268	let out_info = pic_out.get_video_info();
	269	if in_info.is_none() \|\| out_info.is_none() { return Err(ScaleError::InvalidArgument); }
	270	let in_info = in_info.unwrap();
	271	let out_info = out_info.unwrap();
	272	if self.just_convert &&
	273	(in_info.get_width() != out_info.get_width() \|\| in_info.get_height() != out_info.get_height()) {
	274	return Err(ScaleError::InvalidArgument);
	275	}
276	check_format(in_info, &self.fmt_in, self.just_convert)?;
277	check_format(out_info, &self.fmt_out, self.just_convert)?;
278	if let Some(ref mut pipe) = self.pipeline {
279	pipe.process(pic_in, pic_out)
280	} else {
281	copy(pic_in, pic_out);
282	Ok(())
283	}
284	}
285	}
286
287	#[cfg(test)]
288	mod test {
289	use super::*;
290
291	fn fill_pic(pic: &mut NABufferType, val: u8) {
292	if let Some(ref mut buf) = pic.get_vbuf() {
293	let data = buf.get_data_mut().unwrap();
294	for el in data.iter_mut() { *el = val; }
295	} else if let Some(ref mut buf) = pic.get_vbuf16() {
296	let data = buf.get_data_mut().unwrap();
297	for el in data.iter_mut() { *el = val as u16; }
298	} else if let Some(ref mut buf) = pic.get_vbuf32() {
299	let data = buf.get_data_mut().unwrap();
300	for el in data.iter_mut() { el = (val as u32) 0x01010101; }
301	}
302	}
303	#[test]
304	fn test_convert() {
305	let mut in_pic = alloc_video_buffer(NAVideoInfo::new(1, 1, false, RGB565_FORMAT), 3).unwrap();
306	fill_pic(&mut in_pic, 42);
307	let mut out_pic = alloc_video_buffer(NAVideoInfo::new(1, 1, false, RGB24_FORMAT), 3).unwrap();
308	fill_pic(&mut out_pic, 0);
309	let ifmt = get_scale_fmt_from_pic(&in_pic);
310	let ofmt = get_scale_fmt_from_pic(&out_pic);
311	let mut scaler = NAScale::new(ifmt, ofmt).unwrap();
312	scaler.convert(&in_pic, &mut out_pic).unwrap();
313	let obuf = out_pic.get_vbuf().unwrap();
314	let odata = obuf.get_data();
315	assert_eq!(odata[0], 0x0);
316	assert_eq!(odata[1], 0x4);
317	assert_eq!(odata[2], 0x52);
318
319	let mut in_pic = alloc_video_buffer(NAVideoInfo::new(4, 4, false, RGB24_FORMAT), 3).unwrap();
320	fill_pic(&mut in_pic, 42);
321	let mut out_pic = alloc_video_buffer(NAVideoInfo::new(4, 4, false, YUV420_FORMAT), 3).unwrap();
322	fill_pic(&mut out_pic, 0);
323	let ifmt = get_scale_fmt_from_pic(&in_pic);
324	let ofmt = get_scale_fmt_from_pic(&out_pic);
325	let mut scaler = NAScale::new(ifmt, ofmt).unwrap();
326	scaler.convert(&in_pic, &mut out_pic).unwrap();
327	let obuf = out_pic.get_vbuf().unwrap();
328	let yoff = obuf.get_offset(0);
329	let uoff = obuf.get_offset(1);
330	let voff = obuf.get_offset(2);
331	let odata = obuf.get_data();
332	assert_eq!(odata[yoff], 42);
333	assert!(((odata[uoff] ^ 0x80) as i8).abs() <= 1);
334	assert!(((odata[voff] ^ 0x80) as i8).abs() <= 1);
335	let mut scaler = NAScale::new(ofmt, ifmt).unwrap();
336	scaler.convert(&out_pic, &mut in_pic).unwrap();
337	let obuf = in_pic.get_vbuf().unwrap();
338	let odata = obuf.get_data();
339	assert_eq!(odata[0], 42);
340	}
341	#[test]
342	fn test_scale() {
343	let mut in_pic = alloc_video_buffer(NAVideoInfo::new(2, 2, false, RGB565_FORMAT), 3).unwrap();
344	fill_pic(&mut in_pic, 42);
345	let mut out_pic = alloc_video_buffer(NAVideoInfo::new(3, 3, false, RGB565_FORMAT), 3).unwrap();
346	fill_pic(&mut out_pic, 0);
347	let ifmt = get_scale_fmt_from_pic(&in_pic);
348	let ofmt = get_scale_fmt_from_pic(&out_pic);
349	let mut scaler = NAScale::new(ifmt, ofmt).unwrap();
350	scaler.convert(&in_pic, &mut out_pic).unwrap();
351	let obuf = out_pic.get_vbuf16().unwrap();
352	let odata = obuf.get_data();
353	assert_eq!(odata[0], 42);
354	}
355	#[test]
356	fn test_scale_and_convert() {
357	let mut in_pic = alloc_video_buffer(NAVideoInfo::new(7, 3, false, RGB565_FORMAT), 3).unwrap();
358	fill_pic(&mut in_pic, 42);
359	let mut out_pic = alloc_video_buffer(NAVideoInfo::new(4, 4, false, YUV420_FORMAT), 3).unwrap();
360	fill_pic(&mut out_pic, 0);
361	let ifmt = get_scale_fmt_from_pic(&in_pic);
362	let ofmt = get_scale_fmt_from_pic(&out_pic);
363	let mut scaler = NAScale::new(ifmt, ofmt).unwrap();
364	scaler.convert(&in_pic, &mut out_pic).unwrap();
365	let obuf = out_pic.get_vbuf().unwrap();
366	let yoff = obuf.get_offset(0);
367	let uoff = obuf.get_offset(1);
368	let voff = obuf.get_offset(2);
369	let odata = obuf.get_data();
370	assert_eq!(odata[yoff], 28);
371	assert_eq!(odata[uoff], 154);
372	assert_eq!(odata[voff], 103);
373	}
374	}