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 build_pipeline(ifmt: &ScaleInfo, ofmt: &ScaleInfo, just_convert: bool) -> ScaleResult<Option<Stage>> {
 254     let inname  = ifmt.fmt.get_model().get_short_name();
 255     let outname = ofmt.fmt.get_model().get_short_name();
 256
 257 println!("convert {} -> {}", ifmt, ofmt);
 258     let needs_scale = if (ofmt.fmt.get_max_subsampling() > 0) &&
 259         (ofmt.fmt.get_max_subsampling() != ifmt.fmt.get_max_subsampling()) {
 260             true
 261         } else {
 262             !just_convert
 263         };
 264     let needs_unpack = !ifmt.fmt.is_unpacked();
 265     let needs_pack = !ofmt.fmt.is_unpacked();
 266     let needs_convert = inname != outname;
 267     let scale_before_cvt = is_better_fmt(&ifmt, &ofmt) && needs_convert
 268                            && (ofmt.fmt.get_max_subsampling() == 0);
 269     let needs_palettise = ofmt.fmt.palette;
 270 //todo stages for model and gamma conversion
 271
 272     let mut stages: Option<Stage> = None;
 273     let mut cur_fmt = *ifmt;
 274
 275     if needs_unpack {
 276 println!("[adding unpack]");
 277         let new_stage = if !cur_fmt.fmt.is_paletted() {
 278                 Stage::new("unpack", &cur_fmt, &ofmt)?
 279             } else {
 280                 Stage::new("depal", &cur_fmt, &ofmt)?
 281             };
 282         cur_fmt = new_stage.fmt_out;
 283         add_stage!(stages, new_stage);
 284     }
 285     if needs_scale && scale_before_cvt {
 286 println!("[adding scale]");
 287         let new_stage = Stage::new("scale", &cur_fmt, &ofmt)?;
 288         cur_fmt = new_stage.fmt_out;
 289         add_stage!(stages, new_stage);
 290     }
 291     if needs_convert {
 292 println!("[adding convert]");
 293         let cvtname = format!("{}_to_{}", inname, outname);
 294 println!("[{}]", cvtname);
 295         let new_stage = Stage::new(&cvtname, &cur_fmt, &ofmt)?;
 296 //todo if fails try converting via RGB or YUV
 297         cur_fmt = new_stage.fmt_out;
 298         add_stage!(stages, new_stage);
 299 //todo alpha plane copy/add
 300     }
 301     if needs_scale && !scale_before_cvt {
 302 println!("[adding scale]");
 303         let new_stage = Stage::new("scale", &cur_fmt, &ofmt)?;
 304         cur_fmt = new_stage.fmt_out;
 305         add_stage!(stages, new_stage);
 306     }
 307     if needs_pack && !needs_palettise {
 308 println!("[adding pack]");
 309         let new_stage = Stage::new("pack", &cur_fmt, &ofmt)?;
 310         //cur_fmt = new_stage.fmt_out;
 311         add_stage!(stages, new_stage);
 312     }
 313     if needs_palettise {
 314 println!("[adding palettise]");
 315         let new_stage = Stage::new("palette", &cur_fmt, &ofmt)?;
 316         //cur_fmt = new_stage.fmt_out;
 317         add_stage!(stages, new_stage);
 318     }
 319
 320     if let Some(ref mut head) = stages {
 321         head.drop_last_tmp();
 322     }
 323
 324     Ok(stages)
 325 }
 326
 327 fn swap_plane<T:Copy>(data: &mut [T], stride: usize, h: usize, line0: &mut [T], line1: &mut [T]) {
 328     let mut doff0 = 0;
 329     let mut doff1 = stride * (h - 1);
 330     for _ in 0..h/2 {
 331         line0.copy_from_slice(&data[doff0..][..stride]);
 332         line1.copy_from_slice(&data[doff1..][..stride]);
 333         (&mut data[doff1..][..stride]).copy_from_slice(line0);
 334         (&mut data[doff0..][..stride]).copy_from_slice(line1);
 335         doff0 += stride;
 336         doff1 -= stride;
 337     }
 338 }
 339
 340 /// Flips the picture contents.
 341 pub fn flip_picture(pic: &mut NABufferType) -> ScaleResult<()> {
 342     match pic {
 343         NABufferType::Video(ref mut vb) => {
 344             let ncomp = vb.get_num_components();
 345             for comp in 0..ncomp {
 346                 let off    = vb.get_offset(comp);
 347                 let stride = vb.get_stride(comp);
 348                 let (_, h) = vb.get_dimensions(comp);
 349                 let data = vb.get_data_mut().unwrap();
 350                 let mut line0 = vec![0; stride];
 351                 let mut line1 = vec![0; stride];
 352                 swap_plane(&mut data[off..], stride, h, line0.as_mut_slice(), line1.as_mut_slice());
 353             }
 354         },
 355         NABufferType::Video16(ref mut vb) => {
 356             let ncomp = vb.get_num_components().max(1);
 357             for comp in 0..ncomp {
 358                 let off    = vb.get_offset(comp);
 359                 let stride = vb.get_stride(comp);
 360                 let (_, h) = vb.get_dimensions(comp);
 361                 let data = vb.get_data_mut().unwrap();
 362                 let mut line0 = vec![0; stride];
 363                 let mut line1 = vec![0; stride];
 364                 swap_plane(&mut data[off..], stride, h, line0.as_mut_slice(), line1.as_mut_slice());
 365             }
 366         },
 367         NABufferType::Video32(ref mut vb) => {
 368             let ncomp = vb.get_num_components().max(1);
 369             for comp in 0..ncomp {
 370                 let off    = vb.get_offset(comp);
 371                 let stride = vb.get_stride(comp);
 372                 let (_, h) = vb.get_dimensions(comp);
 373                 let data = vb.get_data_mut().unwrap();
 374                 let mut line0 = vec![0; stride];
 375                 let mut line1 = vec![0; stride];
 376                 swap_plane(&mut data[off..], stride, h, line0.as_mut_slice(), line1.as_mut_slice());
 377             }
 378         },
 379         NABufferType::VideoPacked(ref mut vb) => {
 380             let ncomp = vb.get_num_components();
 381             for comp in 0..ncomp {
 382                 let off    = vb.get_offset(comp);
 383                 let stride = vb.get_stride(comp);
 384                 let (_, h) = vb.get_dimensions(comp);
 385                 let data = vb.get_data_mut().unwrap();
 386                 let mut line0 = vec![0; stride];
 387                 let mut line1 = vec![0; stride];
 388                 swap_plane(&mut data[off..], stride, h, line0.as_mut_slice(), line1.as_mut_slice());
 389             }
 390             if ncomp == 0 && vb.get_stride(0) != 0 {
 391                 let off    = vb.get_offset(0);
 392                 let stride = vb.get_stride(0);
 393                 let (_, h) = vb.get_dimensions(0);
 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         },
 400         _ => { return Err(ScaleError::InvalidArgument); },
 401     };
 402     Ok(())
 403 }
 404
 405 impl NAScale {
 406     /// Constructs a new `NAScale` instance.
 407     pub fn new(fmt_in: ScaleInfo, fmt_out: ScaleInfo) -> ScaleResult<Self> {
 408         let pipeline;
 409         let just_convert = (fmt_in.width == fmt_out.width) && (fmt_in.height == fmt_out.height);
 410         if fmt_in != fmt_out {
 411             pipeline = build_pipeline(&fmt_in, &fmt_out, just_convert)?;
 412         } else {
 413             pipeline = None;
 414         }
 415         Ok(Self { fmt_in, fmt_out, just_convert, pipeline })
 416     }
 417     /// Checks whether requested conversion operation is needed at all.
 418     pub fn needs_processing(&self) -> bool { self.pipeline.is_some() }
 419     /// Returns the input image format.
 420     pub fn get_in_fmt(&self) -> ScaleInfo { self.fmt_in }
 421     /// Returns the output image format.
 422     pub fn get_out_fmt(&self) -> ScaleInfo { self.fmt_out }
 423     /// Performs the image format conversion.
 424     pub fn convert(&mut self, pic_in: &NABufferType, pic_out: &mut NABufferType) -> ScaleResult<()> {
 425         let in_info  = pic_in.get_video_info();
 426         let out_info = pic_out.get_video_info();
 427         if in_info.is_none() || out_info.is_none() { return Err(ScaleError::InvalidArgument); }
 428         let in_info  = in_info.unwrap();
 429         let out_info = out_info.unwrap();
 430         if self.just_convert &&
 431                 (in_info.get_width() != out_info.get_width() || in_info.get_height() != out_info.get_height()) {
 432             return Err(ScaleError::InvalidArgument);
 433         }
 434         let needs_flip = in_info.is_flipped() ^ out_info.is_flipped();
 435         check_format(in_info,  &self.fmt_in,  self.just_convert)?;
 436         check_format(out_info, &self.fmt_out, self.just_convert)?;
 437         let ret = if let Some(ref mut pipe) = self.pipeline {
 438                 pipe.process(pic_in, pic_out)
 439             } else {
 440                 copy(pic_in, pic_out);
 441                 Ok(())
 442             };
 443         if ret.is_ok() && needs_flip {
 444             flip_picture(pic_out)?;
 445         }
 446         ret
 447     }
 448 }
 449
 450 #[cfg(test)]
 451 mod test {
 452     use super::*;
 453
 454     fn fill_pic(pic: &mut NABufferType, val: u8) {
 455         if let Some(ref mut buf) = pic.get_vbuf() {
 456             let data = buf.get_data_mut().unwrap();
 457             for el in data.iter_mut() { *el = val; }
 458         } else if let Some(ref mut buf) = pic.get_vbuf16() {
 459             let data = buf.get_data_mut().unwrap();
 460             for el in data.iter_mut() { *el = val as u16; }
 461         } else if let Some(ref mut buf) = pic.get_vbuf32() {
 462             let data = buf.get_data_mut().unwrap();
 463             for el in data.iter_mut() { *el = (val as u32) * 0x01010101; }
 464         }
 465     }
 466     #[test]
 467     fn test_convert() {
 468         let mut in_pic = alloc_video_buffer(NAVideoInfo::new(1, 1, false, RGB565_FORMAT), 3).unwrap();
 469         fill_pic(&mut in_pic, 42);
 470         let mut out_pic = alloc_video_buffer(NAVideoInfo::new(1, 1, false, RGB24_FORMAT), 3).unwrap();
 471         fill_pic(&mut out_pic, 0);
 472         let ifmt = get_scale_fmt_from_pic(&in_pic);
 473         let ofmt = get_scale_fmt_from_pic(&out_pic);
 474         let mut scaler = NAScale::new(ifmt, ofmt).unwrap();
 475         scaler.convert(&in_pic, &mut out_pic).unwrap();
 476         let obuf = out_pic.get_vbuf().unwrap();
 477         let odata = obuf.get_data();
 478         assert_eq!(odata[0], 0x0);
 479         assert_eq!(odata[1], 0x4);
 480         assert_eq!(odata[2], 0x52);
 481
 482         let mut in_pic = alloc_video_buffer(NAVideoInfo::new(4, 4, false, RGB24_FORMAT), 3).unwrap();
 483         fill_pic(&mut in_pic, 42);
 484         let mut out_pic = alloc_video_buffer(NAVideoInfo::new(4, 4, false, YUV420_FORMAT), 3).unwrap();
 485         fill_pic(&mut out_pic, 0);
 486         let ifmt = get_scale_fmt_from_pic(&in_pic);
 487         let ofmt = get_scale_fmt_from_pic(&out_pic);
 488         let mut scaler = NAScale::new(ifmt, ofmt).unwrap();
 489         scaler.convert(&in_pic, &mut out_pic).unwrap();
 490         let obuf = out_pic.get_vbuf().unwrap();
 491         let yoff = obuf.get_offset(0);
 492         let uoff = obuf.get_offset(1);
 493         let voff = obuf.get_offset(2);
 494         let odata = obuf.get_data();
 495         assert_eq!(odata[yoff], 42);
 496         assert!(((odata[uoff] ^ 0x80) as i8).abs() <= 1);
 497         assert!(((odata[voff] ^ 0x80) as i8).abs() <= 1);
 498         let mut scaler = NAScale::new(ofmt, ifmt).unwrap();
 499         scaler.convert(&out_pic, &mut in_pic).unwrap();
 500         let obuf = in_pic.get_vbuf().unwrap();
 501         let odata = obuf.get_data();
 502         assert_eq!(odata[0], 42);
 503     }
 504     #[test]
 505     fn test_scale() {
 506         let mut in_pic = alloc_video_buffer(NAVideoInfo::new(2, 2, false, RGB565_FORMAT), 3).unwrap();
 507         fill_pic(&mut in_pic, 42);
 508         let mut out_pic = alloc_video_buffer(NAVideoInfo::new(3, 3, false, RGB565_FORMAT), 3).unwrap();
 509         fill_pic(&mut out_pic, 0);
 510         let ifmt = get_scale_fmt_from_pic(&in_pic);
 511         let ofmt = get_scale_fmt_from_pic(&out_pic);
 512         let mut scaler = NAScale::new(ifmt, ofmt).unwrap();
 513         scaler.convert(&in_pic, &mut out_pic).unwrap();
 514         let obuf = out_pic.get_vbuf16().unwrap();
 515         let odata = obuf.get_data();
 516         assert_eq!(odata[0], 42);
 517     }
 518     #[test]
 519     fn test_scale_and_convert() {
 520         let mut in_pic = alloc_video_buffer(NAVideoInfo::new(7, 3, false, RGB565_FORMAT), 3).unwrap();
 521         fill_pic(&mut in_pic, 42);
 522         let mut out_pic = alloc_video_buffer(NAVideoInfo::new(4, 4, false, YUV420_FORMAT), 3).unwrap();
 523         fill_pic(&mut out_pic, 0);
 524         let ifmt = get_scale_fmt_from_pic(&in_pic);
 525         let ofmt = get_scale_fmt_from_pic(&out_pic);
 526         let mut scaler = NAScale::new(ifmt, ofmt).unwrap();
 527         scaler.convert(&in_pic, &mut out_pic).unwrap();
 528         let obuf = out_pic.get_vbuf().unwrap();
 529         let yoff = obuf.get_offset(0);
 530         let uoff = obuf.get_offset(1);
 531         let voff = obuf.get_offset(2);
 532         let odata = obuf.get_data();
 533         assert_eq!(odata[yoff], 11);
 534         assert_eq!(odata[uoff], 162);
 535         assert_eq!(odata[voff], 118);
 536     }
 537     #[test]
 538     fn test_scale_and_convert_to_pal() {
 539         let mut in_pic = alloc_video_buffer(NAVideoInfo::new(7, 3, false, YUV420_FORMAT), 3).unwrap();
 540         fill_pic(&mut in_pic, 142);
 541         let mut out_pic = alloc_video_buffer(NAVideoInfo::new(4, 4, false, PAL8_FORMAT), 0).unwrap();
 542         fill_pic(&mut out_pic, 0);
 543         let ifmt = get_scale_fmt_from_pic(&in_pic);
 544         let ofmt = get_scale_fmt_from_pic(&out_pic);
 545         let mut scaler = NAScale::new(ifmt, ofmt).unwrap();
 546         scaler.convert(&in_pic, &mut out_pic).unwrap();
 547         let obuf = out_pic.get_vbuf().unwrap();
 548         let dataoff = obuf.get_offset(0);
 549         let paloff  = obuf.get_offset(1);
 550         let odata = obuf.get_data();
 551         assert_eq!(odata[dataoff], 0);
 552         assert_eq!(odata[paloff], 157);
 553         assert_eq!(odata[paloff + 1], 129);
 554         assert_eq!(odata[paloff + 2], 170);
 555     }
 556 }