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 repack;
  24 #[allow(clippy::module_inception)]
  25 mod scale;
  26
  27 mod palette;
  28
  29 pub use crate::scale::palette::{palettise_frame, QuantisationMode, PaletteSearchMode};
  30
  31 /// Image format information used by the converter.
  32 #[derive(Clone,Copy,PartialEq)]
  33 pub struct ScaleInfo {
  34     /// Pixel format description.
  35     pub fmt:    NAPixelFormaton,
  36     /// Image width.
  37     pub width:  usize,
  38     /// Image height.
  39     pub height: usize,
  40 }
  41
  42 impl std::fmt::Display for ScaleInfo {
  43     fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
  44         write!(f, "({}x{}, {})", self.width, self.height, self.fmt)
  45     }
  46 }
  47
  48 /// A list specifying general image conversion errors.
  49 #[derive(Debug,Clone,Copy,PartialEq)]
  50 #[allow(dead_code)]
  51 pub enum ScaleError {
  52     /// Input or output buffer contains no image data.
  53     NoFrame,
  54     /// Allocation failed.
  55     AllocError,
  56     /// Invalid argument.
  57     InvalidArgument,
  58     /// Feature is not implemented.
  59     NotImplemented,
  60     /// Internal implementation bug.
  61     Bug,
  62 }
  63
  64 /// A specialised `Result` type for image conversion operations.
  65 pub type ScaleResult<T> = Result<T, ScaleError>;
  66
  67 /*trait Kernel {
  68     fn init(&mut self, in_fmt: &ScaleInfo, dest_fmt: &ScaleInfo) -> ScaleResult<NABufferType>;
  69     fn process(&mut self, pic_in: &NABufferType, pic_out: &mut NABufferType);
  70 }*/
  71
  72 struct KernelDesc {
  73     name:       &'static str,
  74     create:     fn () -> Box<dyn kernel::Kernel>,
  75 }
  76
  77 impl KernelDesc {
  78     fn find(name: &str) -> ScaleResult<Box<dyn kernel::Kernel>> {
  79         for kern in KERNELS.iter() {
  80             if kern.name == name {
  81                 return Ok((kern.create)());
  82             }
  83         }
  84         Err(ScaleError::InvalidArgument)
  85     }
  86 }
  87
  88 const KERNELS: &[KernelDesc] = &[
  89     KernelDesc { name: "pack",          create: repack::create_pack },
  90     KernelDesc { name: "unpack",        create: repack::create_unpack },
  91     KernelDesc { name: "depal",         create: repack::create_depal },
  92     KernelDesc { name: "palette",       create: palette::create_palettise },
  93     KernelDesc { name: "scale",         create: scale::create_scale },
  94     KernelDesc { name: "rgb_to_yuv",    create: colorcvt::create_rgb2yuv },
  95     KernelDesc { name: "yuv_to_rgb",    create: colorcvt::create_yuv2rgb },
  96 ];
  97
  98 struct Stage {
  99     fmt_out:    ScaleInfo,
 100     tmp_pic:    NABufferType,
 101     next:       Option<Box<Stage>>,
 102     worker:     Box<dyn kernel::Kernel>,
 103 }
 104
 105 /// Converts input picture information into format used by scaler.
 106 pub fn get_scale_fmt_from_pic(pic: &NABufferType) -> ScaleInfo {
 107     let info = pic.get_video_info().unwrap();
 108     ScaleInfo { fmt: info.get_format(), width: info.get_width(), height: info.get_height() }
 109 }
 110
 111 impl Stage {
 112     fn new(name: &str, in_fmt: &ScaleInfo, dest_fmt: &ScaleInfo) -> ScaleResult<Self> {
 113         let mut worker = KernelDesc::find(name)?;
 114         let tmp_pic = worker.init(in_fmt, dest_fmt)?;
 115         let fmt_out = get_scale_fmt_from_pic(&tmp_pic);
 116         Ok(Self { fmt_out, tmp_pic, next: None, worker })
 117     }
 118     fn add(&mut self, new: Stage) {
 119         if let Some(ref mut next) = self.next {
 120             next.add(new);
 121         } else {
 122             self.next = Some(Box::new(new));
 123         }
 124     }
 125     fn process(&mut self, pic_in: &NABufferType, pic_out: &mut NABufferType) -> ScaleResult<()> {
 126         if let Some(ref mut nextstage) = self.next {
 127             self.worker.process(pic_in, &mut self.tmp_pic);
 128             nextstage.process(&self.tmp_pic, pic_out)?;
 129         } else {
 130             self.worker.process(pic_in, pic_out);
 131         }
 132         Ok(())
 133     }
 134     fn drop_last_tmp(&mut self) {
 135         if let Some(ref mut nextstage) = self.next {
 136             nextstage.drop_last_tmp();
 137         } else {
 138             self.tmp_pic = NABufferType::None;
 139         }
 140     }
 141 }
 142
 143 /// Image format converter.
 144 pub struct NAScale {
 145     fmt_in:         ScaleInfo,
 146     fmt_out:        ScaleInfo,
 147     just_convert:   bool,
 148     pipeline:       Option<Stage>,
 149 }
 150
 151 fn check_format(in_fmt: NAVideoInfo, ref_fmt: &ScaleInfo, just_convert: bool) -> ScaleResult<()> {
 152     if in_fmt.get_format() != ref_fmt.fmt { return Err(ScaleError::InvalidArgument); }
 153     if !just_convert && (in_fmt.get_width() != ref_fmt.width || in_fmt.get_height() != ref_fmt.height) {
 154         return Err(ScaleError::InvalidArgument);
 155     }
 156     Ok(())
 157 }
 158
 159 fn copy(pic_in: &NABufferType, pic_out: &mut NABufferType)
 160 {
 161     if let (Some(ref sbuf), Some(ref mut dbuf)) = (pic_in.get_vbuf(), pic_out.get_vbuf()) {
 162         let mut same = true;
 163         let num_components = sbuf.get_info().get_format().get_num_comp();
 164         for i in 0..num_components {
 165             if sbuf.get_stride(i) != dbuf.get_stride(i) {
 166                 same = false;
 167                 break;
 168             }
 169             if sbuf.get_offset(i) != dbuf.get_offset(i) {
 170                 same = false;
 171                 break;
 172             }
 173         }
 174         if same {
 175             let sdata = sbuf.get_data();
 176             let ddata = dbuf.get_data_mut().unwrap();
 177             ddata.copy_from_slice(&sdata[0..]);
 178         } else {
 179             let sdata = sbuf.get_data();
 180             for comp in 0..num_components {
 181                 let (_, h) = sbuf.get_dimensions(comp);
 182                 let src = &sdata[sbuf.get_offset(comp)..];
 183                 let sstride = sbuf.get_stride(comp);
 184                 let doff = dbuf.get_offset(comp);
 185                 let dstride = dbuf.get_stride(comp);
 186                 let ddata = dbuf.get_data_mut().unwrap();
 187                 let dst = &mut ddata[doff..];
 188                 let copy_size = sstride.min(dstride);
 189                 for (dline, sline) in dst.chunks_exact_mut(dstride).take(h).zip(src.chunks_exact(sstride)) {
 190                     (&mut dline[..copy_size]).copy_from_slice(&sline[..copy_size]);
 191                 }
 192             }
 193         }
 194     } else if let (Some(ref sbuf), Some(ref mut dbuf)) = (pic_in.get_vbuf16(), pic_out.get_vbuf16()) {
 195         let mut same = true;
 196         let num_components = sbuf.get_info().get_format().get_num_comp();
 197         for i in 0..num_components {
 198             if sbuf.get_stride(i) != dbuf.get_stride(i) {
 199                 same = false;
 200                 break;
 201             }
 202             if sbuf.get_offset(i) != dbuf.get_offset(i) {
 203                 same = false;
 204                 break;
 205             }
 206         }
 207         if same {
 208             let sdata = sbuf.get_data();
 209             let ddata = dbuf.get_data_mut().unwrap();
 210             ddata.copy_from_slice(&sdata[0..]);
 211         } else {
 212             let sdata = sbuf.get_data();
 213             for comp in 0..num_components {
 214                 let (_, h) = sbuf.get_dimensions(comp);
 215                 let src = &sdata[sbuf.get_offset(comp)..];
 216                 let sstride = sbuf.get_stride(comp);
 217                 let doff = dbuf.get_offset(comp);
 218                 let dstride = dbuf.get_stride(comp);
 219                 let ddata = dbuf.get_data_mut().unwrap();
 220                 let dst = &mut ddata[doff..];
 221                 let copy_size = sstride.min(dstride);
 222                 for (dline, sline) in dst.chunks_exact_mut(dstride).take(h).zip(src.chunks_exact(sstride)) {
 223                     (&mut dline[..copy_size]).copy_from_slice(&sline[..copy_size]);
 224                 }
 225             }
 226         }
 227     } else {
 228         unimplemented!();
 229     }
 230 }
 231
 232 macro_rules! add_stage {
 233     ($head:expr, $new:expr) => {
 234         if let Some(ref mut h) = $head {
 235             h.add($new);
 236         } else {
 237             $head = Some($new);
 238         }
 239     };
 240 }
 241 fn is_better_fmt(a: &ScaleInfo, b: &ScaleInfo) -> bool {
 242     if (a.width >= b.width) && (a.height >= b.height) {
 243         return true;
 244     }
 245     if a.fmt.get_max_depth() > b.fmt.get_max_depth() {
 246         return true;
 247     }
 248     if a.fmt.get_max_subsampling() < b.fmt.get_max_subsampling() {
 249         return true;
 250     }
 251     false
 252 }
 253 fn fmt_needs_scale(ifmt: &NAPixelFormaton, ofmt: &NAPixelFormaton) -> bool {
 254     for (ichr, ochr) in ifmt.comp_info.iter().zip(ofmt.comp_info.iter()) {
 255         if let (Some(ic), Some(oc)) = (ichr, ochr) {
 256             if ic.h_ss != oc.h_ss || ic.v_ss != oc.v_ss {
 257                 return true;
 258             }
 259         }
 260     }
 261     false
 262 }
 263 fn build_pipeline(ifmt: &ScaleInfo, ofmt: &ScaleInfo, just_convert: bool) -> ScaleResult<Option<Stage>> {
 264     let inname  = ifmt.fmt.get_model().get_short_name();
 265     let outname = ofmt.fmt.get_model().get_short_name();
 266
 267 println!("convert {} -> {}", ifmt, ofmt);
 268     let needs_scale = if fmt_needs_scale(&ifmt.fmt, &ofmt.fmt) {
 269             true
 270         } else {
 271             !just_convert
 272         };
 273     let needs_unpack = !ifmt.fmt.is_unpacked();
 274     let needs_pack = !ofmt.fmt.is_unpacked();
 275     let needs_convert = inname != outname;
 276     let scale_before_cvt = is_better_fmt(&ifmt, &ofmt) && needs_convert
 277                            && (ofmt.fmt.get_max_subsampling() == 0);
 278     let needs_palettise = ofmt.fmt.palette;
 279 //todo stages for model and gamma conversion
 280
 281     let mut stages: Option<Stage> = None;
 282     let mut cur_fmt = *ifmt;
 283
 284     if needs_unpack {
 285 println!("[adding unpack]");
 286         let new_stage = if !cur_fmt.fmt.is_paletted() {
 287                 Stage::new("unpack", &cur_fmt, &ofmt)?
 288             } else {
 289                 Stage::new("depal", &cur_fmt, &ofmt)?
 290             };
 291         cur_fmt = new_stage.fmt_out;
 292         add_stage!(stages, new_stage);
 293     }
 294     if needs_scale && scale_before_cvt {
 295 println!("[adding scale]");
 296         let new_stage = Stage::new("scale", &cur_fmt, &ofmt)?;
 297         cur_fmt = new_stage.fmt_out;
 298         add_stage!(stages, new_stage);
 299     }
 300     if needs_convert {
 301 println!("[adding convert]");
 302         let cvtname = format!("{}_to_{}", inname, outname);
 303 println!("[{}]", cvtname);
 304         let new_stage = Stage::new(&cvtname, &cur_fmt, &ofmt)?;
 305 //todo if fails try converting via RGB or YUV
 306         cur_fmt = new_stage.fmt_out;
 307         add_stage!(stages, new_stage);
 308 //todo alpha plane copy/add
 309     }
 310     if needs_scale && !scale_before_cvt {
 311 println!("[adding scale]");
 312         let new_stage = Stage::new("scale", &cur_fmt, &ofmt)?;
 313         cur_fmt = new_stage.fmt_out;
 314         add_stage!(stages, new_stage);
 315     }
 316     if needs_pack && !needs_palettise {
 317 println!("[adding pack]");
 318         let new_stage = Stage::new("pack", &cur_fmt, &ofmt)?;
 319         //cur_fmt = new_stage.fmt_out;
 320         add_stage!(stages, new_stage);
 321     }
 322     if needs_palettise {
 323 println!("[adding palettise]");
 324         let new_stage = Stage::new("palette", &cur_fmt, &ofmt)?;
 325         //cur_fmt = new_stage.fmt_out;
 326         add_stage!(stages, new_stage);
 327     }
 328
 329     if let Some(ref mut head) = stages {
 330         head.drop_last_tmp();
 331     }
 332
 333     Ok(stages)
 334 }
 335
 336 fn swap_plane<T:Copy>(data: &mut [T], stride: usize, h: usize, line0: &mut [T], line1: &mut [T]) {
 337     let mut doff0 = 0;
 338     let mut doff1 = stride * (h - 1);
 339     for _ in 0..h/2 {
 340         line0.copy_from_slice(&data[doff0..][..stride]);
 341         line1.copy_from_slice(&data[doff1..][..stride]);
 342         (&mut data[doff1..][..stride]).copy_from_slice(line0);
 343         (&mut data[doff0..][..stride]).copy_from_slice(line1);
 344         doff0 += stride;
 345         doff1 -= stride;
 346     }
 347 }
 348
 349 /// Flips the picture contents.
 350 pub fn flip_picture(pic: &mut NABufferType) -> ScaleResult<()> {
 351     match pic {
 352         NABufferType::Video(ref mut vb) => {
 353             let ncomp = vb.get_num_components();
 354             for comp in 0..ncomp {
 355                 let off    = vb.get_offset(comp);
 356                 let stride = vb.get_stride(comp);
 357                 let (_, h) = vb.get_dimensions(comp);
 358                 let data = vb.get_data_mut().unwrap();
 359                 let mut line0 = vec![0; stride];
 360                 let mut line1 = vec![0; stride];
 361                 swap_plane(&mut data[off..], stride, h, line0.as_mut_slice(), line1.as_mut_slice());
 362             }
 363         },
 364         NABufferType::Video16(ref mut vb) => {
 365             let ncomp = vb.get_num_components().max(1);
 366             for comp in 0..ncomp {
 367                 let off    = vb.get_offset(comp);
 368                 let stride = vb.get_stride(comp);
 369                 let (_, h) = vb.get_dimensions(comp);
 370                 let data = vb.get_data_mut().unwrap();
 371                 let mut line0 = vec![0; stride];
 372                 let mut line1 = vec![0; stride];
 373                 swap_plane(&mut data[off..], stride, h, line0.as_mut_slice(), line1.as_mut_slice());
 374             }
 375         },
 376         NABufferType::Video32(ref mut vb) => {
 377             let ncomp = vb.get_num_components().max(1);
 378             for comp in 0..ncomp {
 379                 let off    = vb.get_offset(comp);
 380                 let stride = vb.get_stride(comp);
 381                 let (_, h) = vb.get_dimensions(comp);
 382                 let data = vb.get_data_mut().unwrap();
 383                 let mut line0 = vec![0; stride];
 384                 let mut line1 = vec![0; stride];
 385                 swap_plane(&mut data[off..], stride, h, line0.as_mut_slice(), line1.as_mut_slice());
 386             }
 387         },
 388         NABufferType::VideoPacked(ref mut vb) => {
 389             let ncomp = vb.get_num_components();
 390             for comp in 0..ncomp {
 391                 let off    = vb.get_offset(comp);
 392                 let stride = vb.get_stride(comp);
 393                 let (_, h) = vb.get_dimensions(comp);
 394                 let data = vb.get_data_mut().unwrap();
 395                 let mut line0 = vec![0; stride];
 396                 let mut line1 = vec![0; stride];
 397                 swap_plane(&mut data[off..], stride, h, line0.as_mut_slice(), line1.as_mut_slice());
 398             }
 399             if ncomp == 0 && vb.get_stride(0) != 0 {
 400                 let off    = vb.get_offset(0);
 401                 let stride = vb.get_stride(0);
 402                 let (_, h) = vb.get_dimensions(0);
 403                 let data = vb.get_data_mut().unwrap();
 404                 let mut line0 = vec![0; stride];
 405                 let mut line1 = vec![0; stride];
 406                 swap_plane(&mut data[off..], stride, h, line0.as_mut_slice(), line1.as_mut_slice());
 407             }
 408         },
 409         _ => { return Err(ScaleError::InvalidArgument); },
 410     };
 411     Ok(())
 412 }
 413
 414 impl NAScale {
 415     /// Constructs a new `NAScale` instance.
 416     pub fn new(fmt_in: ScaleInfo, fmt_out: ScaleInfo) -> ScaleResult<Self> {
 417         let pipeline;
 418         let just_convert = (fmt_in.width == fmt_out.width) && (fmt_in.height == fmt_out.height);
 419         if fmt_in != fmt_out {
 420             pipeline = build_pipeline(&fmt_in, &fmt_out, just_convert)?;
 421         } else {
 422             pipeline = None;
 423         }
 424         Ok(Self { fmt_in, fmt_out, just_convert, pipeline })
 425     }
 426     /// Checks whether requested conversion operation is needed at all.
 427     pub fn needs_processing(&self) -> bool { self.pipeline.is_some() }
 428     /// Returns the input image format.
 429     pub fn get_in_fmt(&self) -> ScaleInfo { self.fmt_in }
 430     /// Returns the output image format.
 431     pub fn get_out_fmt(&self) -> ScaleInfo { self.fmt_out }
 432     /// Performs the image format conversion.
 433     pub fn convert(&mut self, pic_in: &NABufferType, pic_out: &mut NABufferType) -> ScaleResult<()> {
 434         let in_info  = pic_in.get_video_info();
 435         let out_info = pic_out.get_video_info();
 436         if in_info.is_none() || out_info.is_none() { return Err(ScaleError::InvalidArgument); }
 437         let in_info  = in_info.unwrap();
 438         let out_info = out_info.unwrap();
 439         if self.just_convert &&
 440                 (in_info.get_width() != out_info.get_width() || in_info.get_height() != out_info.get_height()) {
 441             return Err(ScaleError::InvalidArgument);
 442         }
 443         let needs_flip = in_info.is_flipped() ^ out_info.is_flipped();
 444         check_format(in_info,  &self.fmt_in,  self.just_convert)?;
 445         check_format(out_info, &self.fmt_out, self.just_convert)?;
 446         let ret = if let Some(ref mut pipe) = self.pipeline {
 447                 pipe.process(pic_in, pic_out)
 448             } else {
 449                 copy(pic_in, pic_out);
 450                 Ok(())
 451             };
 452         if ret.is_ok() && needs_flip {
 453             flip_picture(pic_out)?;
 454         }
 455         ret
 456     }
 457 }
 458
 459 #[cfg(test)]
 460 mod test {
 461     use super::*;
 462
 463     fn fill_pic(pic: &mut NABufferType, val: u8) {
 464         if let Some(ref mut buf) = pic.get_vbuf() {
 465             let data = buf.get_data_mut().unwrap();
 466             for el in data.iter_mut() { *el = val; }
 467         } else if let Some(ref mut buf) = pic.get_vbuf16() {
 468             let data = buf.get_data_mut().unwrap();
 469             for el in data.iter_mut() { *el = val as u16; }
 470         } else if let Some(ref mut buf) = pic.get_vbuf32() {
 471             let data = buf.get_data_mut().unwrap();
 472             for el in data.iter_mut() { *el = (val as u32) * 0x01010101; }
 473         }
 474     }
 475     #[test]
 476     fn test_convert() {
 477         let mut in_pic = alloc_video_buffer(NAVideoInfo::new(1, 1, false, RGB565_FORMAT), 3).unwrap();
 478         fill_pic(&mut in_pic, 42);
 479         let mut out_pic = alloc_video_buffer(NAVideoInfo::new(1, 1, false, RGB24_FORMAT), 3).unwrap();
 480         fill_pic(&mut out_pic, 0);
 481         let ifmt = get_scale_fmt_from_pic(&in_pic);
 482         let ofmt = get_scale_fmt_from_pic(&out_pic);
 483         let mut scaler = NAScale::new(ifmt, ofmt).unwrap();
 484         scaler.convert(&in_pic, &mut out_pic).unwrap();
 485         let obuf = out_pic.get_vbuf().unwrap();
 486         let odata = obuf.get_data();
 487         assert_eq!(odata[0], 0x0);
 488         assert_eq!(odata[1], 0x4);
 489         assert_eq!(odata[2], 0x52);
 490
 491         let mut in_pic = alloc_video_buffer(NAVideoInfo::new(4, 4, false, RGB24_FORMAT), 3).unwrap();
 492         fill_pic(&mut in_pic, 42);
 493         let mut out_pic = alloc_video_buffer(NAVideoInfo::new(4, 4, false, YUV420_FORMAT), 3).unwrap();
 494         fill_pic(&mut out_pic, 0);
 495         let ifmt = get_scale_fmt_from_pic(&in_pic);
 496         let ofmt = get_scale_fmt_from_pic(&out_pic);
 497         let mut scaler = NAScale::new(ifmt, ofmt).unwrap();
 498         scaler.convert(&in_pic, &mut out_pic).unwrap();
 499         let obuf = out_pic.get_vbuf().unwrap();
 500         let yoff = obuf.get_offset(0);
 501         let uoff = obuf.get_offset(1);
 502         let voff = obuf.get_offset(2);
 503         let odata = obuf.get_data();
 504         assert_eq!(odata[yoff], 42);
 505         assert!(((odata[uoff] ^ 0x80) as i8).abs() <= 1);
 506         assert!(((odata[voff] ^ 0x80) as i8).abs() <= 1);
 507         let mut scaler = NAScale::new(ofmt, ifmt).unwrap();
 508         scaler.convert(&out_pic, &mut in_pic).unwrap();
 509         let obuf = in_pic.get_vbuf().unwrap();
 510         let odata = obuf.get_data();
 511         assert_eq!(odata[0], 42);
 512     }
 513     #[test]
 514     fn test_scale() {
 515         let mut in_pic = alloc_video_buffer(NAVideoInfo::new(2, 2, false, RGB565_FORMAT), 3).unwrap();
 516         fill_pic(&mut in_pic, 42);
 517         let mut out_pic = alloc_video_buffer(NAVideoInfo::new(3, 3, false, RGB565_FORMAT), 3).unwrap();
 518         fill_pic(&mut out_pic, 0);
 519         let ifmt = get_scale_fmt_from_pic(&in_pic);
 520         let ofmt = get_scale_fmt_from_pic(&out_pic);
 521         let mut scaler = NAScale::new(ifmt, ofmt).unwrap();
 522         scaler.convert(&in_pic, &mut out_pic).unwrap();
 523         let obuf = out_pic.get_vbuf16().unwrap();
 524         let odata = obuf.get_data();
 525         assert_eq!(odata[0], 42);
 526     }
 527     #[test]
 528     fn test_scale_and_convert() {
 529         let mut in_pic = alloc_video_buffer(NAVideoInfo::new(7, 3, false, RGB565_FORMAT), 3).unwrap();
 530         fill_pic(&mut in_pic, 42);
 531         let mut out_pic = alloc_video_buffer(NAVideoInfo::new(4, 4, false, YUV420_FORMAT), 3).unwrap();
 532         fill_pic(&mut out_pic, 0);
 533         let ifmt = get_scale_fmt_from_pic(&in_pic);
 534         let ofmt = get_scale_fmt_from_pic(&out_pic);
 535         let mut scaler = NAScale::new(ifmt, ofmt).unwrap();
 536         scaler.convert(&in_pic, &mut out_pic).unwrap();
 537         let obuf = out_pic.get_vbuf().unwrap();
 538         let yoff = obuf.get_offset(0);
 539         let uoff = obuf.get_offset(1);
 540         let voff = obuf.get_offset(2);
 541         let odata = obuf.get_data();
 542         assert_eq!(odata[yoff], 11);
 543         assert_eq!(odata[uoff], 162);
 544         assert_eq!(odata[voff], 118);
 545     }
 546     #[test]
 547     fn test_scale_and_convert_to_pal() {
 548         let mut in_pic = alloc_video_buffer(NAVideoInfo::new(7, 3, false, YUV420_FORMAT), 3).unwrap();
 549         fill_pic(&mut in_pic, 142);
 550         let mut out_pic = alloc_video_buffer(NAVideoInfo::new(4, 4, false, PAL8_FORMAT), 0).unwrap();
 551         fill_pic(&mut out_pic, 0);
 552         let ifmt = get_scale_fmt_from_pic(&in_pic);
 553         let ofmt = get_scale_fmt_from_pic(&out_pic);
 554         let mut scaler = NAScale::new(ifmt, ofmt).unwrap();
 555         scaler.convert(&in_pic, &mut out_pic).unwrap();
 556         let obuf = out_pic.get_vbuf().unwrap();
 557         let dataoff = obuf.get_offset(0);
 558         let paloff  = obuf.get_offset(1);
 559         let odata = obuf.get_data();
 560         assert_eq!(odata[dataoff], 0);
 561         assert_eq!(odata[paloff], 157);
 562         assert_eq!(odata[paloff + 1], 129);
 563         assert_eq!(odata[paloff + 2], 170);
 564     }
 565 }