nihav-core/src/scale/mod.rs

   1 //! Image conversion functionality.
   2
   3 //! # Examples
   4 //!
   5 //! Convert input image into YUV one and scale down two times.
   6 //! ```no_run
   7 //! use nihav_core::scale::*;
   8 //! use nihav_core::formats::{RGB24_FORMAT, YUV420_FORMAT};
   9 //! use nihav_core::frame::{alloc_video_buffer, NAVideoInfo};
  10 //!
  11 //! let mut in_pic = alloc_video_buffer(NAVideoInfo::new(640, 480, false, RGB24_FORMAT), 4).unwrap();
  12 //! let mut out_pic = alloc_video_buffer(NAVideoInfo::new(320, 240, false, YUV420_FORMAT), 4).unwrap();
  13 //! let in_fmt = get_scale_fmt_from_pic(&in_pic);
  14 //! let out_fmt = get_scale_fmt_from_pic(&out_pic);
  15 //! let mut scaler = NAScale::new(in_fmt, out_fmt).unwrap();
  16 //! scaler.convert(&in_pic, &mut out_pic).unwrap();
  17 //! ```
  18 use crate::frame::*;
  19
  20 mod kernel;
  21
  22 mod colorcvt;
  23 mod depth;
  24 mod fill;
  25 mod repack;
  26 #[allow(clippy::module_inception)]
  27 mod scale;
  28
  29 mod palette;
  30
  31 pub use crate::scale::palette::{palettise_frame, QuantisationMode, PaletteSearchMode};
  32
  33 /// Image format information used by the converter.
  34 #[derive(Clone,Copy,PartialEq)]
  35 pub struct ScaleInfo {
  36     /// Pixel format description.
  37     pub fmt:    NAPixelFormaton,
  38     /// Image width.
  39     pub width:  usize,
  40     /// Image height.
  41     pub height: usize,
  42 }
  43
  44 impl std::fmt::Display for ScaleInfo {
  45     fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
  46         write!(f, "({}x{}, {})", self.width, self.height, self.fmt)
  47     }
  48 }
  49
  50 /// A list specifying general image conversion errors.
  51 #[derive(Debug,Clone,Copy,PartialEq)]
  52 #[allow(dead_code)]
  53 pub enum ScaleError {
  54     /// Input or output buffer contains no image data.
  55     NoFrame,
  56     /// Allocation failed.
  57     AllocError,
  58     /// Invalid argument.
  59     InvalidArgument,
  60     /// Feature is not implemented.
  61     NotImplemented,
  62     /// Internal implementation bug.
  63     Bug,
  64 }
  65
  66 /// A specialised `Result` type for image conversion operations.
  67 pub type ScaleResult<T> = Result<T, ScaleError>;
  68
  69 /*trait Kernel {
  70     fn init(&mut self, in_fmt: &ScaleInfo, dest_fmt: &ScaleInfo) -> ScaleResult<NABufferType>;
  71     fn process(&mut self, pic_in: &NABufferType, pic_out: &mut NABufferType);
  72 }*/
  73
  74 struct KernelDesc {
  75     name:       &'static str,
  76     create:     fn () -> Box<dyn kernel::Kernel>,
  77 }
  78
  79 impl KernelDesc {
  80     fn find(name: &str) -> ScaleResult<Box<dyn kernel::Kernel>> {
  81         for kern in KERNELS.iter() {
  82             if kern.name == name {
  83                 return Ok((kern.create)());
  84             }
  85         }
  86         Err(ScaleError::InvalidArgument)
  87     }
  88 }
  89
  90 const KERNELS: &[KernelDesc] = &[
  91     KernelDesc { name: "pack",          create: repack::create_pack },
  92     KernelDesc { name: "unpack",        create: repack::create_unpack },
  93     KernelDesc { name: "depal",         create: repack::create_depal },
  94     KernelDesc { name: "palette",       create: palette::create_palettise },
  95     KernelDesc { name: "scale",         create: scale::create_scale },
  96     KernelDesc { name: "shallow",       create: depth::create_shallow },
  97     KernelDesc { name: "fill",          create: fill::create_fill },
  98     KernelDesc { name: "rgb_to_yuv",    create: colorcvt::create_rgb2yuv },
  99     KernelDesc { name: "yuv_to_rgb",    create: colorcvt::create_yuv2rgb },
 100 ];
 101
 102 struct Stage {
 103     fmt_out:    ScaleInfo,
 104     tmp_pic:    NABufferType,
 105     next:       Option<Box<Stage>>,
 106     worker:     Box<dyn kernel::Kernel>,
 107 }
 108
 109 /// Converts input picture information into format used by scaler.
 110 pub fn get_scale_fmt_from_pic(pic: &NABufferType) -> ScaleInfo {
 111     let info = pic.get_video_info().unwrap();
 112     ScaleInfo { fmt: info.get_format(), width: info.get_width(), height: info.get_height() }
 113 }
 114
 115 impl Stage {
 116     fn new(name: &str, in_fmt: &ScaleInfo, dest_fmt: &ScaleInfo, options: &[(String, String)]) -> ScaleResult<Self> {
 117         let mut worker = KernelDesc::find(name)?;
 118         let tmp_pic = worker.init(in_fmt, dest_fmt, options)?;
 119         let fmt_out = get_scale_fmt_from_pic(&tmp_pic);
 120         Ok(Self { fmt_out, tmp_pic, next: None, worker })
 121     }
 122     fn add(&mut self, new: Stage) {
 123         if let Some(ref mut next) = self.next {
 124             next.add(new);
 125         } else {
 126             self.next = Some(Box::new(new));
 127         }
 128     }
 129     fn process(&mut self, pic_in: &NABufferType, pic_out: &mut NABufferType) -> ScaleResult<()> {
 130         if let Some(ref mut nextstage) = self.next {
 131             self.worker.process(pic_in, &mut self.tmp_pic);
 132             nextstage.process(&self.tmp_pic, pic_out)?;
 133         } else {
 134             self.worker.process(pic_in, pic_out);
 135         }
 136         Ok(())
 137     }
 138     fn drop_last_tmp(&mut self) {
 139         if let Some(ref mut nextstage) = self.next {
 140             nextstage.drop_last_tmp();
 141         } else {
 142             self.tmp_pic = NABufferType::None;
 143         }
 144     }
 145 }
 146
 147 /// Image format converter.
 148 pub struct NAScale {
 149     fmt_in:         ScaleInfo,
 150     fmt_out:        ScaleInfo,
 151     just_convert:   bool,
 152     pipeline:       Option<Stage>,
 153 }
 154
 155 fn check_format(in_fmt: NAVideoInfo, ref_fmt: &ScaleInfo, just_convert: bool) -> ScaleResult<()> {
 156     if in_fmt.get_format() != ref_fmt.fmt { return Err(ScaleError::InvalidArgument); }
 157     if !just_convert && (in_fmt.get_width() != ref_fmt.width || in_fmt.get_height() != ref_fmt.height) {
 158         return Err(ScaleError::InvalidArgument);
 159     }
 160     Ok(())
 161 }
 162
 163 fn copy(pic_in: &NABufferType, pic_out: &mut NABufferType)
 164 {
 165     if let (Some(ref sbuf), Some(ref mut dbuf)) = (pic_in.get_vbuf(), pic_out.get_vbuf()) {
 166         if sbuf.get_info().get_format().is_paletted() {
 167             let same = sbuf.get_stride(0) == dbuf.get_stride(0) && sbuf.get_offset(1) == dbuf.get_offset(1);
 168             if same {
 169                 let src = sbuf.get_data();
 170                 let dst = dbuf.get_data_mut().unwrap();
 171                 dst.copy_from_slice(src);
 172             } else {
 173                 let (_, h) = sbuf.get_dimensions(0);
 174                 let soff = sbuf.get_offset(0);
 175                 let spoff = sbuf.get_offset(1);
 176                 let sstride = sbuf.get_stride(0);
 177                 let src = sbuf.get_data();
 178                 let doff = dbuf.get_offset(0);
 179                 let dpoff = dbuf.get_offset(1);
 180                 let dstride = dbuf.get_stride(0);
 181                 let dst = dbuf.get_data_mut().unwrap();
 182                 let copy_size = sstride.min(dstride);
 183                 for (dline, sline) in dst[doff..].chunks_exact_mut(dstride).take(h).zip(src[soff..].chunks_exact(sstride)) {
 184                     dline[..copy_size].copy_from_slice(&sline[..copy_size]);
 185                 }
 186                 dst[dpoff..].copy_from_slice(&src[spoff..]);
 187             }
 188             return;
 189         }
 190         let mut same = true;
 191         let src_components = sbuf.get_info().get_format().get_num_comp();
 192         let dst_components = dbuf.get_info().get_format().get_num_comp();
 193         for i in 0..src_components.max(dst_components) {
 194             if sbuf.get_stride(i) != dbuf.get_stride(i) {
 195                 same = false;
 196                 break;
 197             }
 198             if sbuf.get_offset(i) != dbuf.get_offset(i) {
 199                 same = false;
 200                 break;
 201             }
 202         }
 203         if same {
 204             let sdata = sbuf.get_data();
 205             let ddata = dbuf.get_data_mut().unwrap();
 206             ddata.copy_from_slice(&sdata[0..]);
 207         } else {
 208             let sdata = sbuf.get_data();
 209             for comp in 0..src_components.min(dst_components) {
 210                 let (_, h) = sbuf.get_dimensions(comp);
 211                 let src = &sdata[sbuf.get_offset(comp)..];
 212                 let sstride = sbuf.get_stride(comp);
 213                 let doff = dbuf.get_offset(comp);
 214                 let dstride = dbuf.get_stride(comp);
 215                 let ddata = dbuf.get_data_mut().unwrap();
 216                 let dst = &mut ddata[doff..];
 217                 let copy_size = sstride.min(dstride);
 218                 for (dline, sline) in dst.chunks_exact_mut(dstride).take(h).zip(src.chunks_exact(sstride)) {
 219                     dline[..copy_size].copy_from_slice(&sline[..copy_size]);
 220                 }
 221             }
 222         }
 223     } else if let (Some(ref sbuf), Some(ref mut dbuf)) = (pic_in.get_vbuf16(), pic_out.get_vbuf16()) {
 224         let mut same = true;
 225         let src_components = sbuf.get_info().get_format().get_num_comp();
 226         let dst_components = dbuf.get_info().get_format().get_num_comp();
 227         for i in 0..src_components.max(dst_components) {
 228             if sbuf.get_stride(i) != dbuf.get_stride(i) {
 229                 same = false;
 230                 break;
 231             }
 232             if sbuf.get_offset(i) != dbuf.get_offset(i) {
 233                 same = false;
 234                 break;
 235             }
 236         }
 237         if same {
 238             let sdata = sbuf.get_data();
 239             let ddata = dbuf.get_data_mut().unwrap();
 240             let copy_len = sdata.len().min(ddata.len());
 241             ddata[..copy_len].copy_from_slice(&sdata[..copy_len]);
 242         } else {
 243             let sdata = sbuf.get_data();
 244             for comp in 0..src_components.min(dst_components) {
 245                 let (_, h) = sbuf.get_dimensions(comp);
 246                 let src = &sdata[sbuf.get_offset(comp)..];
 247                 let sstride = sbuf.get_stride(comp);
 248                 let doff = dbuf.get_offset(comp);
 249                 let dstride = dbuf.get_stride(comp);
 250                 let ddata = dbuf.get_data_mut().unwrap();
 251                 let dst = &mut ddata[doff..];
 252                 let copy_size = sstride.min(dstride);
 253                 for (dline, sline) in dst.chunks_exact_mut(dstride).take(h).zip(src.chunks_exact(sstride)) {
 254                     dline[..copy_size].copy_from_slice(&sline[..copy_size]);
 255                 }
 256             }
 257         }
 258     } else {
 259         unimplemented!();
 260     }
 261 }
 262
 263 macro_rules! add_stage {
 264     ($head:expr, $new:expr) => {
 265         if let Some(ref mut h) = $head {
 266             h.add($new);
 267         } else {
 268             $head = Some($new);
 269         }
 270     };
 271 }
 272 fn is_better_fmt(a: &ScaleInfo, b: &ScaleInfo) -> bool {
 273     if (a.width >= b.width) && (a.height >= b.height) {
 274         return true;
 275     }
 276     if a.fmt.get_max_depth() > b.fmt.get_max_depth() {
 277         return true;
 278     }
 279     if a.fmt.get_max_subsampling() < b.fmt.get_max_subsampling() {
 280         return true;
 281     }
 282     false
 283 }
 284 fn fmt_needs_scale(ifmt: &NAPixelFormaton, ofmt: &NAPixelFormaton) -> bool {
 285     for (ichr, ochr) in ifmt.comp_info.iter().zip(ofmt.comp_info.iter()) {
 286         if let (Some(ic), Some(oc)) = (ichr, ochr) {
 287             if ic.h_ss != oc.h_ss || ic.v_ss != oc.v_ss {
 288                 return true;
 289             }
 290         }
 291     }
 292     false
 293 }
 294 fn build_pipeline(ifmt: &ScaleInfo, ofmt: &ScaleInfo, just_convert: bool, options: &[(String, String)]) -> ScaleResult<Option<Stage>> {
 295     let mut debug = false;
 296     for (name, value) in options.iter() {
 297         if name == "debug" && (value.is_empty() || value == "true") {
 298             debug = true;
 299             break;
 300         }
 301     }
 302
 303     let inname  = ifmt.fmt.get_model().get_short_name();
 304     let outname = ofmt.fmt.get_model().get_short_name();
 305
 306     if debug {
 307         println!("convert {} -> {}", ifmt, ofmt);
 308     }
 309     let needs_scale = if fmt_needs_scale(&ifmt.fmt, &ofmt.fmt) {
 310             true
 311         } else {
 312             !just_convert
 313         };
 314     let needs_unpack = !ifmt.fmt.is_unpacked();
 315     let needs_pack = !ofmt.fmt.is_unpacked();
 316     let needs_convert = inname != outname;
 317     let scale_before_cvt = is_better_fmt(ifmt, ofmt) && needs_convert
 318                            && (ofmt.fmt.get_max_subsampling() == 0);
 319     let needs_palettise = ofmt.fmt.palette;
 320 //todo stages for model and gamma conversion
 321
 322     let mut stages: Option<Stage> = None;
 323     let mut cur_fmt = *ifmt;
 324
 325     if needs_unpack {
 326         if debug {
 327             println!("[adding unpack]");
 328         }
 329         let new_stage = if !cur_fmt.fmt.is_paletted() {
 330                 Stage::new("unpack", &cur_fmt, ofmt, options)?
 331             } else {
 332                 Stage::new("depal", &cur_fmt, ofmt, options)?
 333             };
 334         cur_fmt = new_stage.fmt_out;
 335         add_stage!(stages, new_stage);
 336     }
 337     if needs_scale && scale_before_cvt {
 338         if debug {
 339             println!("[adding scale]");
 340         }
 341         let new_stage = Stage::new("scale", &cur_fmt, ofmt, options)?;
 342         cur_fmt = new_stage.fmt_out;
 343         add_stage!(stages, new_stage);
 344     }
 345     if needs_convert {
 346         if debug {
 347             println!("[adding convert]");
 348         }
 349         let cvtname = format!("{}_to_{}", inname, outname);
 350         if debug {
 351             println!("[{}]", cvtname);
 352         }
 353         let new_stage = Stage::new(&cvtname, &cur_fmt, ofmt, options)?;
 354 //todo if fails try converting via RGB or YUV
 355         cur_fmt = new_stage.fmt_out;
 356         add_stage!(stages, new_stage);
 357 //todo alpha plane copy/add
 358     }
 359     if needs_scale && !scale_before_cvt {
 360         if debug {
 361             println!("[adding scale]");
 362         }
 363         let new_stage = Stage::new("scale", &cur_fmt, ofmt, options)?;
 364         cur_fmt = new_stage.fmt_out;
 365         add_stage!(stages, new_stage);
 366     }
 367     let is_in_high_bd = cur_fmt.fmt.get_max_depth() > 8;
 368     let is_out_high_bd = ofmt.fmt.get_max_depth() > 8;
 369     if is_in_high_bd && !is_out_high_bd {
 370         if debug {
 371             println!("[adding shallow]");
 372         }
 373         let new_stage = Stage::new("shallow", &cur_fmt, ofmt, options)?;
 374         cur_fmt = new_stage.fmt_out;
 375         add_stage!(stages, new_stage);
 376     }
 377     let icomponents = cur_fmt.fmt.components - if cur_fmt.fmt.alpha { 1 } else { 0 };
 378     let ocomponents = ofmt.fmt.components - if ofmt.fmt.alpha { 1 } else { 0 };
 379     if !needs_palettise && ((!cur_fmt.fmt.alpha && ofmt.fmt.alpha) || (icomponents < ocomponents)) {
 380         if debug {
 381             println!("[adding fill]");
 382         }
 383         let new_stage = Stage::new("fill", &cur_fmt, ofmt, options)?;
 384         cur_fmt = new_stage.fmt_out;
 385         add_stage!(stages, new_stage);
 386     }
 387     if needs_pack && !needs_palettise {
 388         if debug {
 389             println!("[adding pack]");
 390         }
 391         let new_stage = Stage::new("pack", &cur_fmt, ofmt, options)?;
 392         //cur_fmt = new_stage.fmt_out;
 393         add_stage!(stages, new_stage);
 394     }
 395     if needs_palettise {
 396         if debug {
 397             println!("[adding palettise]");
 398         }
 399         let new_stage = Stage::new("palette", &cur_fmt, ofmt, options)?;
 400         //cur_fmt = new_stage.fmt_out;
 401         add_stage!(stages, new_stage);
 402     }
 403
 404     if let Some(ref mut head) = stages {
 405         head.drop_last_tmp();
 406     }
 407
 408     Ok(stages)
 409 }
 410
 411 fn swap_plane<T:Copy>(data: &mut [T], stride: usize, h: usize, line0: &mut [T], line1: &mut [T]) {
 412     let mut doff0 = 0;
 413     let mut doff1 = stride * (h - 1);
 414     for _ in 0..h/2 {
 415         line0.copy_from_slice(&data[doff0..][..stride]);
 416         line1.copy_from_slice(&data[doff1..][..stride]);
 417         data[doff1..][..stride].copy_from_slice(line0);
 418         data[doff0..][..stride].copy_from_slice(line1);
 419         doff0 += stride;
 420         doff1 -= stride;
 421     }
 422 }
 423
 424 /// Flips the picture contents.
 425 pub fn flip_picture(pic: &mut NABufferType) -> ScaleResult<()> {
 426     match pic {
 427         NABufferType::Video(ref mut vb) => {
 428             let ncomp = vb.get_num_components();
 429             for comp in 0..ncomp {
 430                 let off    = vb.get_offset(comp);
 431                 let stride = vb.get_stride(comp);
 432                 let (_, h) = vb.get_dimensions(comp);
 433                 let data = vb.get_data_mut().unwrap();
 434                 let mut line0 = vec![0; stride];
 435                 let mut line1 = vec![0; stride];
 436                 swap_plane(&mut data[off..], stride, h, line0.as_mut_slice(), line1.as_mut_slice());
 437             }
 438         },
 439         NABufferType::Video16(ref mut vb) => {
 440             let ncomp = vb.get_num_components().max(1);
 441             for comp in 0..ncomp {
 442                 let off    = vb.get_offset(comp);
 443                 let stride = vb.get_stride(comp);
 444                 let (_, h) = vb.get_dimensions(comp);
 445                 let data = vb.get_data_mut().unwrap();
 446                 let mut line0 = vec![0; stride];
 447                 let mut line1 = vec![0; stride];
 448                 swap_plane(&mut data[off..], stride, h, line0.as_mut_slice(), line1.as_mut_slice());
 449             }
 450         },
 451         NABufferType::Video32(ref mut vb) => {
 452             let ncomp = vb.get_num_components().max(1);
 453             for comp in 0..ncomp {
 454                 let off    = vb.get_offset(comp);
 455                 let stride = vb.get_stride(comp);
 456                 let (_, h) = vb.get_dimensions(comp);
 457                 let data = vb.get_data_mut().unwrap();
 458                 let mut line0 = vec![0; stride];
 459                 let mut line1 = vec![0; stride];
 460                 swap_plane(&mut data[off..], stride, h, line0.as_mut_slice(), line1.as_mut_slice());
 461             }
 462         },
 463         NABufferType::VideoPacked(ref mut vb) => {
 464             let ncomp = vb.get_num_components();
 465             for comp in 0..ncomp {
 466                 let off    = vb.get_offset(comp);
 467                 let stride = vb.get_stride(comp);
 468                 let (_, h) = vb.get_dimensions(comp);
 469                 let data = vb.get_data_mut().unwrap();
 470                 let mut line0 = vec![0; stride];
 471                 let mut line1 = vec![0; stride];
 472                 swap_plane(&mut data[off..], stride, h, line0.as_mut_slice(), line1.as_mut_slice());
 473             }
 474             if ncomp == 0 && vb.get_stride(0) != 0 {
 475                 let off    = vb.get_offset(0);
 476                 let stride = vb.get_stride(0);
 477                 let (_, h) = vb.get_dimensions(0);
 478                 let data = vb.get_data_mut().unwrap();
 479                 let mut line0 = vec![0; stride];
 480                 let mut line1 = vec![0; stride];
 481                 swap_plane(&mut data[off..], stride, h, line0.as_mut_slice(), line1.as_mut_slice());
 482             }
 483         },
 484         _ => { return Err(ScaleError::InvalidArgument); },
 485     };
 486     Ok(())
 487 }
 488
 489 impl NAScale {
 490     /// Constructs a new `NAScale` instance.
 491     pub fn new(fmt_in: ScaleInfo, fmt_out: ScaleInfo) -> ScaleResult<Self> {
 492         let just_convert = (fmt_in.width == fmt_out.width) && (fmt_in.height == fmt_out.height);
 493         let pipeline = if fmt_in != fmt_out {
 494                 build_pipeline(&fmt_in, &fmt_out, just_convert, &[])?
 495             } else {
 496                 None
 497             };
 498         Ok(Self { fmt_in, fmt_out, just_convert, pipeline })
 499     }
 500     /// Constructs a new `NAScale` instance taking into account provided options.
 501     pub fn new_with_options(fmt_in: ScaleInfo, fmt_out: ScaleInfo, options: &[(String, String)]) -> ScaleResult<Self> {
 502         let just_convert = (fmt_in.width == fmt_out.width) && (fmt_in.height == fmt_out.height);
 503         let pipeline = if fmt_in != fmt_out {
 504                 build_pipeline(&fmt_in, &fmt_out, just_convert, options)?
 505             } else {
 506                 None
 507             };
 508         Ok(Self { fmt_in, fmt_out, just_convert, pipeline })
 509     }
 510     /// Checks whether requested conversion operation is needed at all.
 511     pub fn needs_processing(&self) -> bool { self.pipeline.is_some() }
 512     /// Returns the input image format.
 513     pub fn get_in_fmt(&self) -> ScaleInfo { self.fmt_in }
 514     /// Returns the output image format.
 515     pub fn get_out_fmt(&self) -> ScaleInfo { self.fmt_out }
 516     /// Performs the image format conversion.
 517     pub fn convert(&mut self, pic_in: &NABufferType, pic_out: &mut NABufferType) -> ScaleResult<()> {
 518         let in_info  = pic_in.get_video_info();
 519         let out_info = pic_out.get_video_info();
 520         if in_info.is_none() || out_info.is_none() { return Err(ScaleError::InvalidArgument); }
 521         let in_info  = in_info.unwrap();
 522         let out_info = out_info.unwrap();
 523         if self.just_convert &&
 524                 (in_info.get_width() != out_info.get_width() || in_info.get_height() != out_info.get_height()) {
 525             return Err(ScaleError::InvalidArgument);
 526         }
 527         let needs_flip = in_info.is_flipped() ^ out_info.is_flipped();
 528         check_format(in_info,  &self.fmt_in,  self.just_convert)?;
 529         check_format(out_info, &self.fmt_out, self.just_convert)?;
 530         let ret = if let Some(ref mut pipe) = self.pipeline {
 531                 pipe.process(pic_in, pic_out)
 532             } else {
 533                 copy(pic_in, pic_out);
 534                 Ok(())
 535             };
 536         if ret.is_ok() && needs_flip {
 537             flip_picture(pic_out)?;
 538         }
 539         ret
 540     }
 541 }
 542
 543 #[cfg(test)]
 544 mod test {
 545     use super::*;
 546
 547     fn fill_pic(pic: &mut NABufferType, val: u8) {
 548         if let Some(ref mut buf) = pic.get_vbuf() {
 549             let data = buf.get_data_mut().unwrap();
 550             for el in data.iter_mut() { *el = val; }
 551         } else if let Some(ref mut buf) = pic.get_vbuf16() {
 552             let data = buf.get_data_mut().unwrap();
 553             for el in data.iter_mut() { *el = val as u16; }
 554         } else if let Some(ref mut buf) = pic.get_vbuf32() {
 555             let data = buf.get_data_mut().unwrap();
 556             for el in data.iter_mut() { *el = (val as u32) * 0x01010101; }
 557         }
 558     }
 559     #[test]
 560     fn test_convert() {
 561         let mut in_pic = alloc_video_buffer(NAVideoInfo::new(1, 1, false, RGB565_FORMAT), 3).unwrap();
 562         fill_pic(&mut in_pic, 42);
 563         let mut out_pic = alloc_video_buffer(NAVideoInfo::new(1, 1, false, RGB24_FORMAT), 3).unwrap();
 564         fill_pic(&mut out_pic, 0);
 565         let ifmt = get_scale_fmt_from_pic(&in_pic);
 566         let ofmt = get_scale_fmt_from_pic(&out_pic);
 567         let mut scaler = NAScale::new(ifmt, ofmt).unwrap();
 568         scaler.convert(&in_pic, &mut out_pic).unwrap();
 569         let obuf = out_pic.get_vbuf().unwrap();
 570         let odata = obuf.get_data();
 571         assert_eq!(odata[0], 0x0);
 572         assert_eq!(odata[1], 0x4);
 573         assert_eq!(odata[2], 0x52);
 574
 575         let mut in_pic = alloc_video_buffer(NAVideoInfo::new(4, 4, false, RGB24_FORMAT), 3).unwrap();
 576         fill_pic(&mut in_pic, 42);
 577         let mut out_pic = alloc_video_buffer(NAVideoInfo::new(4, 4, false, YUV420_FORMAT), 3).unwrap();
 578         fill_pic(&mut out_pic, 0);
 579         let ifmt = get_scale_fmt_from_pic(&in_pic);
 580         let ofmt = get_scale_fmt_from_pic(&out_pic);
 581         let mut scaler = NAScale::new(ifmt, ofmt).unwrap();
 582         scaler.convert(&in_pic, &mut out_pic).unwrap();
 583         let obuf = out_pic.get_vbuf().unwrap();
 584         let yoff = obuf.get_offset(0);
 585         let uoff = obuf.get_offset(1);
 586         let voff = obuf.get_offset(2);
 587         let odata = obuf.get_data();
 588         assert_eq!(odata[yoff], 42);
 589         assert!(((odata[uoff] ^ 0x80) as i8).abs() <= 1);
 590         assert!(((odata[voff] ^ 0x80) as i8).abs() <= 1);
 591         let mut scaler = NAScale::new(ofmt, ifmt).unwrap();
 592         scaler.convert(&out_pic, &mut in_pic).unwrap();
 593         let obuf = in_pic.get_vbuf().unwrap();
 594         let odata = obuf.get_data();
 595         assert_eq!(odata[0], 42);
 596     }
 597     #[test]
 598     fn test_scale() {
 599         let mut in_pic = alloc_video_buffer(NAVideoInfo::new(2, 2, false, RGB565_FORMAT), 3).unwrap();
 600         fill_pic(&mut in_pic, 42);
 601         let mut out_pic = alloc_video_buffer(NAVideoInfo::new(3, 3, false, RGB565_FORMAT), 3).unwrap();
 602         fill_pic(&mut out_pic, 0);
 603         let ifmt = get_scale_fmt_from_pic(&in_pic);
 604         let ofmt = get_scale_fmt_from_pic(&out_pic);
 605         let mut scaler = NAScale::new(ifmt, ofmt).unwrap();
 606         scaler.convert(&in_pic, &mut out_pic).unwrap();
 607         let obuf = out_pic.get_vbuf16().unwrap();
 608         let odata = obuf.get_data();
 609         assert_eq!(odata[0], 42);
 610     }
 611     #[test]
 612     fn test_scale_and_convert() {
 613         let mut in_pic = alloc_video_buffer(NAVideoInfo::new(7, 3, false, RGB565_FORMAT), 3).unwrap();
 614         fill_pic(&mut in_pic, 42);
 615         let mut out_pic = alloc_video_buffer(NAVideoInfo::new(4, 4, false, YUV420_FORMAT), 3).unwrap();
 616         fill_pic(&mut out_pic, 0);
 617         let ifmt = get_scale_fmt_from_pic(&in_pic);
 618         let ofmt = get_scale_fmt_from_pic(&out_pic);
 619         let mut scaler = NAScale::new(ifmt, ofmt).unwrap();
 620         scaler.convert(&in_pic, &mut out_pic).unwrap();
 621         let obuf = out_pic.get_vbuf().unwrap();
 622         let yoff = obuf.get_offset(0);
 623         let uoff = obuf.get_offset(1);
 624         let voff = obuf.get_offset(2);
 625         let odata = obuf.get_data();
 626         assert_eq!(odata[yoff], 11);
 627         assert_eq!(odata[uoff], 162);
 628         assert_eq!(odata[voff], 118);
 629     }
 630     #[test]
 631     fn test_scale_and_convert_to_pal() {
 632         let mut in_pic = alloc_video_buffer(NAVideoInfo::new(7, 3, false, YUV420_FORMAT), 3).unwrap();
 633         fill_pic(&mut in_pic, 142);
 634         let mut out_pic = alloc_video_buffer(NAVideoInfo::new(4, 4, false, PAL8_FORMAT), 0).unwrap();
 635         fill_pic(&mut out_pic, 0);
 636         let ifmt = get_scale_fmt_from_pic(&in_pic);
 637         let ofmt = get_scale_fmt_from_pic(&out_pic);
 638         let mut scaler = NAScale::new(ifmt, ofmt).unwrap();
 639         scaler.convert(&in_pic, &mut out_pic).unwrap();
 640         let obuf = out_pic.get_vbuf().unwrap();
 641         let dataoff = obuf.get_offset(0);
 642         let paloff  = obuf.get_offset(1);
 643         let odata = obuf.get_data();
 644         assert_eq!(odata[dataoff], 0);
 645         assert_eq!(odata[paloff], 157);
 646         assert_eq!(odata[paloff + 1], 129);
 647         assert_eq!(odata[paloff + 2], 170);
 648     }
 649     #[test]
 650     fn test_scale_modes() {
 651         const IN_DATA: [[u8; 6]; 2] = [
 652             [0xFF, 0xC0, 0x40, 0x00, 0x40, 0xC0],
 653             [0x00, 0x40, 0xC0, 0xFF, 0xC0, 0x40]
 654         ];
 655         const TEST_DATA: &[(&str, [[u8; 9]; 3])] = &[
 656             ("nn",
 657                [[0xFF, 0xC0, 0x40, 0xFF, 0xC0, 0x40, 0x00, 0x40, 0xC0],
 658                 [0xFF, 0xC0, 0x40, 0xFF, 0xC0, 0x40, 0x00, 0x40, 0xC0],
 659                 [0x00, 0x40, 0xC0, 0x00, 0x40, 0xC0, 0xFF, 0xC0, 0x40]]),
 660             ("bilin",
 661                [[0xFF, 0xC0, 0x40, 0x55, 0x6A, 0x95, 0x00, 0x40, 0xC0],
 662                 [0x55, 0x6A, 0x95, 0x8D, 0x86, 0x78, 0xAA, 0x95, 0x6A],
 663                 [0x00, 0x40, 0xC0, 0xAA, 0x95, 0x6A, 0xFF, 0xC0, 0x40]]),
 664             ("bicubic",
 665                [[0xFF, 0xC0, 0x40, 0x4B, 0x65, 0x9A, 0x00, 0x36, 0xC9],
 666                 [0x4B, 0x65, 0x9A, 0x94, 0x8A, 0x74, 0xB3, 0x9D, 0x61],
 667                 [0x00, 0x36, 0xC9, 0xBA, 0x9D, 0x61, 0xFF, 0xD3, 0x2B]]),
 668             ("lanczos",
 669                [[0xFF, 0xC0, 0x40, 0x4C, 0x66, 0x98, 0x00, 0x31, 0xCD],
 670                 [0x4C, 0x66, 0x98, 0x91, 0x88, 0x74, 0xB1, 0x9D, 0x5F],
 671                 [0x00, 0x31, 0xCD, 0xBB, 0x9D, 0x5F, 0xFF, 0xDD, 0x1E]]),
 672             ("lanczos2",
 673                [[0xFF, 0xC0, 0x40, 0x4F, 0x68, 0x9B, 0x00, 0x35, 0xCD],
 674                 [0x4F, 0x68, 0x9B, 0x96, 0x8D, 0x79, 0xB3, 0xA0, 0x64],
 675                 [0x00, 0x35, 0xCD, 0xBE, 0xA1, 0x65, 0xFF, 0xDC, 0x28]]),
 676         ];
 677
 678         let in_pic = alloc_video_buffer(NAVideoInfo::new(2, 2, false, RGB24_FORMAT), 3).unwrap();
 679         if let Some(ref mut vbuf) = in_pic.get_vbuf() {
 680             let stride = vbuf.get_stride(0);
 681             let data = vbuf.get_data_mut().unwrap();
 682             for (dline, rline) in data.chunks_mut(stride).zip(IN_DATA.iter()) {
 683                 dline[..6].copy_from_slice(rline);
 684             }
 685         } else {
 686             panic!("wrong format");
 687         }
 688         let mut out_pic = alloc_video_buffer(NAVideoInfo::new(3, 3, false, RGB24_FORMAT), 3).unwrap();
 689         let ifmt = get_scale_fmt_from_pic(&in_pic);
 690         let ofmt = get_scale_fmt_from_pic(&out_pic);
 691         for (method, ref_data) in TEST_DATA.iter() {
 692             fill_pic(&mut out_pic, 0);
 693             let mut scaler = NAScale::new_with_options(ifmt, ofmt, &[("scaler".to_string(), method.to_string())]).unwrap();
 694             scaler.convert(&in_pic, &mut out_pic).unwrap();
 695             let obuf = out_pic.get_vbuf().unwrap();
 696             let ostride = obuf.get_stride(0);
 697             let odata = obuf.get_data();
 698             for (oline, rline) in odata.chunks(ostride).zip(ref_data.iter()) {
 699                 for (&a, &b) in oline.iter().zip(rline.iter()) {
 700                     assert_eq!(a, b);
 701                 }
 702             }
 703         }
 704     }
 705 }