nihav-commonfmt/src/codecs/zmbvenc.rs

   1 use nihav_core::codecs::*;
   2 use nihav_core::compr::deflate::{Deflate, DeflateMode, DeflateWriter};
   3 use nihav_core::io::byteio::*;
   4
   5 const RGB555_FORMAT: NAPixelFormaton = NAPixelFormaton { model: ColorModel::RGB(RGBSubmodel::RGB), components: 3,
   6                                         comp_info: [
   7                                             Some(NAPixelChromaton{ h_ss: 0, v_ss: 0, packed: true, depth: 5, shift: 10, comp_offs: 0, next_elem: 2 }),
   8                                             Some(NAPixelChromaton{ h_ss: 0, v_ss: 0, packed: true, depth: 5, shift:  5, comp_offs: 0, next_elem: 2 }),
   9                                             Some(NAPixelChromaton{ h_ss: 0, v_ss: 0, packed: true, depth: 5, shift:  0, comp_offs: 0, next_elem: 2 }),
  10                                             None, None],
  11                                         elem_size: 2, be: false, alpha: false, palette: false };
  12 const RGB24_0_FORMAT: NAPixelFormaton = NAPixelFormaton { model: ColorModel::RGB(RGBSubmodel::RGB), components: 3,
  13                                         comp_info: [
  14                                             Some(NAPixelChromaton{ h_ss: 0, v_ss: 0, packed: true, depth: 8, shift: 0, comp_offs: 2, next_elem: 4 }),
  15                                             Some(NAPixelChromaton{ h_ss: 0, v_ss: 0, packed: true, depth: 8, shift: 0, comp_offs: 1, next_elem: 4 }),
  16                                             Some(NAPixelChromaton{ h_ss: 0, v_ss: 0, packed: true, depth: 8, shift: 0, comp_offs: 0, next_elem: 4 }),
  17                                             None, None],
  18                                         elem_size: 4, be: false, alpha: false, palette: false };
  19
  20 struct ZMBVEncoder {
  21     stream:     Option<NAStreamRef>,
  22     frm1:       Vec<u8>,
  23     frm2:       Vec<u8>,
  24     tmp_buf:    Vec<u8>,
  25     zbuf:       Vec<u8>,
  26     pal:        [u8; 768],
  27     pkt:        Option<NAPacket>,
  28     frmcount:   u8,
  29     key_int:    u8,
  30     tile_w:     usize,
  31     tile_h:     usize,
  32     cmode:      DeflateMode,
  33     compr:      Deflate,
  34     bpp:        u8,
  35     width:      usize,
  36     height:     usize,
  37     range:      usize,
  38     sent_pal:   bool,
  39 }
  40
  41 fn buf_type_to_bpp(buf: &NABufferType) -> u8 {
  42     match buf {
  43         NABufferType::Video(ref vbuf) => {
  44             let vinfo = vbuf.get_info();
  45             if vinfo.get_format().is_paletted() {
  46                 8
  47             } else {
  48                 vinfo.get_format().get_total_depth()
  49             }
  50         },
  51         NABufferType::VideoPacked(ref vbuf) => {
  52             let vinfo = vbuf.get_info();
  53             vinfo.get_format().elem_size * 8
  54         },
  55         NABufferType::Video16(ref vbuf) => {
  56             let vinfo = vbuf.get_info();
  57             vinfo.get_format().get_total_depth()
  58         },
  59         _ => 0,
  60     }
  61 }
  62
  63 fn copy_frame(buf: NABufferType, dst: &mut [u8], bpp: u8) -> EncoderResult<()> {
  64     match buf {
  65         NABufferType::Video(ref vbuf) => {
  66             if bpp != 8 {
  67                 return Err(EncoderError::FormatError);
  68             }
  69             let off     = vbuf.get_offset(0);
  70             let stride  = vbuf.get_stride(0);
  71             let data    = vbuf.get_data();
  72             let w       = vbuf.get_info().get_width();
  73             let h       = vbuf.get_info().get_height();
  74
  75             for (dline, sline) in dst.chunks_mut(w).zip(data[off..].chunks(stride)).take(h) {
  76                 dline[..w].copy_from_slice(&sline[..w]);
  77             }
  78         },
  79         NABufferType::Video16(ref vbuf) => {
  80             let off     = vbuf.get_offset(0);
  81             let stride  = vbuf.get_stride(0);
  82             let data    = vbuf.get_data();
  83             let w       = vbuf.get_info().get_width();
  84             let h       = vbuf.get_info().get_height();
  85
  86             for (dline, sline) in dst.chunks_mut(w * 2).zip(data[off..].chunks(stride)).take(h) {
  87                 for (dst, &src) in dline[..w * 2].chunks_exact_mut(2).zip(sline.iter()) {
  88                     dst[0] = src as u8;
  89                     dst[1] = (src >> 8) as u8;
  90                 }
  91             }
  92         },
  93         NABufferType::VideoPacked(ref vbuf) => {
  94             let off     = vbuf.get_offset(0);
  95             let stride  = vbuf.get_stride(0);
  96             let data    = vbuf.get_data();
  97             let w       = vbuf.get_info().get_width();
  98             let h       = vbuf.get_info().get_height();
  99             let w = w * (((bpp as usize) + 7) / 8);
 100
 101             for (dline, sline) in dst.chunks_mut(w).zip(data[off..].chunks(stride)).take(h) {
 102                 dline[..w].copy_from_slice(&sline[..w]);
 103             }
 104         },
 105         _ => return Err(EncoderError::FormatError),
 106     };
 107     Ok(())
 108 }
 109
 110 fn to_signed(val: usize) -> isize {
 111     if (val & 1) == 0 {
 112         (val >> 1) as isize
 113     } else {
 114         -((val >> 1) as isize) - 1
 115     }
 116 }
 117
 118 impl ZMBVEncoder {
 119     fn new() -> Self {
 120         Self {
 121             stream:     None,
 122             pkt:        None,
 123             frm1:       Vec::new(),
 124             frm2:       Vec::new(),
 125             pal:        [0; 768],
 126             tmp_buf:    Vec::new(),
 127             zbuf:       Vec::new(),
 128             frmcount:   0,
 129             key_int:    25,
 130             tile_w:     16,
 131             tile_h:     16,
 132             cmode:      DeflateMode::default(),
 133             compr:      Deflate::new(DeflateMode::default()),
 134             bpp:        0,
 135             width:      0,
 136             height:     0,
 137             range:      128,
 138             sent_pal:   false,
 139         }
 140     }
 141     fn encode_intra(&mut self, bw: &mut ByteWriter, buf: NABufferType) -> EncoderResult<()> {
 142         let bpp = buf_type_to_bpp(&buf);
 143
 144         if let NABufferType::None = buf {
 145             if self.bpp == 0 {
 146                 return Err(EncoderError::FormatError);
 147             }
 148             self.frm1.copy_from_slice(&self.frm2);
 149         } else {
 150             if bpp == 0 {
 151                 return Err(EncoderError::FormatError);
 152             }
 153             self.bpp = bpp;
 154
 155             if let (NABufferType::Video(ref vbuf), true) = (&buf, bpp == 8) {
 156                 let off = vbuf.get_offset(1);
 157                 let data = vbuf.get_data();
 158                 self.pal.copy_from_slice(&data[off..][..768]);
 159             }
 160
 161             copy_frame(buf, &mut self.frm1, self.bpp)?;
 162         }
 163
 164         bw.write_byte(1)?; // intra flag
 165         bw.write_byte(0)?; // high version
 166         bw.write_byte(1)?; // low version
 167         bw.write_byte(if self.cmode == DeflateMode::NoCompr { 0 } else { 1 })?;
 168         let fmt = match self.bpp {
 169                  8 => 4,
 170                 15 => 5,
 171                 16 => 6,
 172                 24 => 7,
 173                 32 => 8,
 174                  _ => unreachable!(),
 175             };
 176         bw.write_byte(fmt)?;
 177         bw.write_byte(self.tile_w as u8)?;
 178         bw.write_byte(self.tile_h as u8)?;
 179
 180         let bm = ((bpp as usize) + 7) / 8;
 181         if self.cmode == DeflateMode::NoCompr {
 182             if bpp == 8 {
 183                 bw.write_buf(&self.pal)?;
 184             }
 185             bw.write_buf(&self.frm1[..self.width * self.height * bm])?;
 186         } else {
 187             self.tmp_buf.clear();
 188             if bpp == 8 {
 189                 self.tmp_buf.extend_from_slice(&self.pal);
 190             }
 191             self.tmp_buf.extend_from_slice(&self.frm1[..self.width * self.height * bm]);
 192             self.compr = Deflate::new(self.cmode);
 193
 194             let mut db = Vec::new();
 195             std::mem::swap(&mut db, &mut self.zbuf);
 196             db.clear();
 197             let mut wr = DeflateWriter::new(db);
 198             self.compr.write_zlib_header(&mut wr);
 199             self.compr.compress(&self.tmp_buf, &mut wr);
 200             self.compr.compress_flush(&mut wr);
 201             let mut db = wr.end();
 202             std::mem::swap(&mut db, &mut self.zbuf);
 203
 204             bw.write_buf(&self.zbuf)?;
 205         }
 206
 207         Ok(())
 208     }
 209     fn encode_inter(&mut self, bw: &mut ByteWriter, buf: NABufferType) -> EncoderResult<()> {
 210         if let NABufferType::None = buf {
 211             self.frm1.copy_from_slice(&self.frm2);
 212
 213             bw.write_byte(0)?;
 214             self.tmp_buf.clear();
 215             let tile_w = (self.width  + self.tile_w - 1) / self.tile_w;
 216             let tile_h = (self.height + self.tile_h - 1) / self.tile_h;
 217             let mv_size = (tile_w * tile_h * 2 + 3) & !3;
 218             for _ in 0..mv_size {
 219                 self.tmp_buf.push(0);
 220             }
 221             if self.cmode == DeflateMode::NoCompr {
 222                 bw.write_buf(&self.tmp_buf)?;
 223             } else {
 224                 let mut db = Vec::new();
 225
 226                 std::mem::swap(&mut db, &mut self.zbuf);
 227                 db.clear();
 228                 let mut wr = DeflateWriter::new(db);
 229                 self.compr.compress(&self.tmp_buf, &mut wr);
 230                 self.compr.compress_flush(&mut wr);
 231                 let mut db = wr.end();
 232                 std::mem::swap(&mut db, &mut self.zbuf);
 233
 234                 bw.write_buf(&self.zbuf)?;
 235             }
 236             return Ok(());
 237         }
 238         let bpp = buf_type_to_bpp(&buf);
 239         if bpp == 0 || bpp != self.bpp {
 240             return Err(EncoderError::FormatError);
 241         }
 242
 243         self.tmp_buf.clear();
 244         if let (NABufferType::Video(ref vbuf), true) = (&buf, bpp == 8) {
 245             let mut npal = [0; 768];
 246             let off = vbuf.get_offset(1);
 247             let data = vbuf.get_data();
 248             npal.copy_from_slice(&data[off..][..768]);
 249             let mut cmp = true;
 250             for (&a, &b) in self.pal.iter().zip(npal.iter()) {
 251                 if a != b {
 252                     cmp = false;
 253                     break;
 254                 }
 255             }
 256             if !cmp {
 257                 for (&a, &b) in self.pal.iter().zip(npal.iter()) {
 258                     self.tmp_buf.push(a ^ b);
 259                 }
 260                 self.pal = npal;
 261
 262                 bw.write_byte(2)?;
 263
 264                 self.sent_pal = false;
 265             } else {
 266                 bw.write_byte(0)?;
 267             }
 268         } else {
 269             bw.write_byte(0)?;
 270         }
 271         copy_frame(buf, &mut self.frm1, self.bpp)?;
 272
 273         let tile_w = (self.width  + self.tile_w - 1) / self.tile_w;
 274         let tile_h = (self.height + self.tile_h - 1) / self.tile_h;
 275         let mut mv_start = self.tmp_buf.len();
 276         let mv_size = (tile_w * tile_h * 2 + 3) & !3;
 277         for _ in 0..mv_size {
 278             self.tmp_buf.push(0);
 279         }
 280
 281         let bpp = ((self.bpp as usize) + 7) / 8;
 282         let stride = self.width * bpp;
 283         let mut off = 0;
 284         for y in (0..self.height).step_by(self.tile_h) {
 285             let cur_h = (self.height - y).min(self.tile_h);
 286             for x in (0..self.width).step_by(self.tile_w) {
 287                 let cur_w = (self.width - x).min(self.tile_w);
 288
 289                 let mut best_dist = std::u32::MAX;
 290                 let mut best_x = x;
 291                 let mut best_y = y;
 292
 293                 'search: for yoff in 0..self.range {
 294                     let ypos = (y as isize) + to_signed(yoff);
 295                     if ypos < 0 {
 296                         continue;
 297                     }
 298                     let ypos = ypos as usize;
 299                     if ypos + cur_h > self.height {
 300                         break;
 301                     }
 302                     for xoff in 0..self.range {
 303                         let xpos = (x as isize) + to_signed(xoff);
 304                         if xpos < 0 {
 305                             continue;
 306                         }
 307                         let xpos = xpos as usize;
 308                         if xpos + cur_w > self.width {
 309                             break;
 310                         }
 311
 312                         let mut diff = 0;
 313                         let roff = xpos * bpp + ypos * stride;
 314                         for (line0, line1) in self.frm1[off..].chunks(stride).take(cur_h).zip(self.frm2[roff..].chunks(stride)) {
 315                             for (&a, &b) in line0[..cur_w * bpp].iter().zip(line1[..cur_w * bpp].iter()) {
 316                                 diff += u32::from(a ^ b);
 317                             }
 318                         }
 319
 320                         if best_dist > diff {
 321                             best_dist = diff;
 322                             best_x = xpos;
 323                             best_y = ypos;
 324                             if diff == 0 {
 325                                 break 'search;
 326                             }
 327                         }
 328                     }
 329                 }
 330
 331                 let has_delta = best_dist != 0;
 332                 self.tmp_buf[mv_start] = (best_x.wrapping_sub(x) << 1) as u8;
 333                 if has_delta {
 334                     self.tmp_buf[mv_start] |= 1;
 335                 }
 336                 self.tmp_buf[mv_start + 1] = (best_y.wrapping_sub(y) << 1) as u8;
 337                 mv_start += 2;
 338                 if has_delta {
 339                     let rpos = best_x * bpp + best_y * stride;
 340                     for (line0, line1) in self.frm1[off..].chunks(stride).take(cur_h).zip(self.frm2[rpos..].chunks(stride)) {
 341                         for (&a, &b) in line0[..cur_w * bpp].iter().zip(line1[..cur_w * bpp].iter()) {
 342                             self.tmp_buf.push(a ^ b);
 343                         }
 344                     }
 345                 }
 346
 347                 off += self.tile_w * bpp;
 348             }
 349             off -= tile_w * self.tile_w * bpp;
 350             off += stride * self.tile_h;
 351         }
 352
 353         if self.cmode == DeflateMode::NoCompr {
 354             bw.write_buf(&self.tmp_buf)?;
 355         } else {
 356             let mut db = Vec::new();
 357
 358             std::mem::swap(&mut db, &mut self.zbuf);
 359             db.clear();
 360             let mut wr = DeflateWriter::new(db);
 361             self.compr.compress(&self.tmp_buf, &mut wr);
 362             self.compr.compress_flush(&mut wr);
 363             let mut db = wr.end();
 364             std::mem::swap(&mut db, &mut self.zbuf);
 365
 366             bw.write_buf(&self.zbuf)?;
 367         }
 368
 369         Ok(())
 370     }
 371 }
 372
 373 impl NAEncoder for ZMBVEncoder {
 374     fn negotiate_format(&self, encinfo: &EncodeParameters) -> EncoderResult<EncodeParameters> {
 375         match encinfo.format {
 376             NACodecTypeInfo::None => {
 377                 Ok(EncodeParameters {
 378                     format: NACodecTypeInfo::Video(NAVideoInfo::new(0, 0, true, YUV420_FORMAT)),
 379                     ..Default::default()
 380                 })
 381             },
 382             NACodecTypeInfo::Audio(_) => Err(EncoderError::FormatError),
 383             NACodecTypeInfo::Video(vinfo) => {
 384                 let depth = vinfo.format.get_total_depth();
 385                 let pix_fmt = if vinfo.format.is_paletted() {
 386                         PAL8_FORMAT
 387                     } else if !vinfo.format.model.is_rgb() || depth > 16 {
 388                         RGB24_0_FORMAT
 389                     } else if depth < 16 {
 390                         RGB555_FORMAT
 391                     } else {
 392                         RGB565_FORMAT
 393                     };
 394                 let outinfo = NAVideoInfo::new(vinfo.width, vinfo.height, false, pix_fmt);
 395                 let mut ofmt = *encinfo;
 396                 ofmt.format = NACodecTypeInfo::Video(outinfo);
 397                 Ok(ofmt)
 398             }
 399         }
 400     }
 401     fn get_capabilities(&self) -> u64 { ENC_CAPS_SKIPFRAME }
 402     fn init(&mut self, stream_id: u32, encinfo: EncodeParameters) -> EncoderResult<NAStreamRef> {
 403         match encinfo.format {
 404             NACodecTypeInfo::None => Err(EncoderError::FormatError),
 405             NACodecTypeInfo::Audio(_) => Err(EncoderError::FormatError),
 406             NACodecTypeInfo::Video(vinfo) => {
 407                 self.width  = vinfo.width;
 408                 self.height = vinfo.height;
 409
 410                 let out_info = NAVideoInfo::new(vinfo.width, vinfo.height, false, vinfo.format);
 411                 let info = NACodecInfo::new("zmbv", NACodecTypeInfo::Video(out_info), None);
 412                 let mut stream = NAStream::new(StreamType::Video, stream_id, info, encinfo.tb_num, encinfo.tb_den, 0);
 413                 stream.set_num(stream_id as usize);
 414                 let stream = stream.into_ref();
 415
 416                 self.stream = Some(stream.clone());
 417
 418                 self.frm1 = vec![0; vinfo.width * vinfo.height * 4];
 419                 self.frm2 = vec![0; vinfo.width * vinfo.height * 4];
 420
 421                 Ok(stream)
 422             },
 423         }
 424     }
 425     fn encode(&mut self, frm: &NAFrame) -> EncoderResult<()> {
 426         let buf = frm.get_buffer();
 427         let mut dbuf = Vec::with_capacity(4);
 428         let mut gw   = GrowableMemoryWriter::new_write(&mut dbuf);
 429         let mut bw   = ByteWriter::new(&mut gw);
 430         let is_intra = if self.frmcount == 0 {
 431                 self.encode_intra(&mut bw, buf)?;
 432                 true
 433             } else {
 434                 self.encode_inter(&mut bw, buf)?;
 435                 false
 436             };
 437         self.pkt = Some(NAPacket::new(self.stream.clone().unwrap(), frm.ts, is_intra, dbuf));
 438         if self.bpp == 8 && !self.sent_pal {
 439             if let NABufferType::Video(ref buf) = frm.get_buffer() {
 440                 let paloff = buf.get_offset(1);
 441                 let data = buf.get_data();
 442                 let mut pal = [0; 1024];
 443                 let srcpal = &data[paloff..][..768];
 444                 for (dclr, sclr) in pal.chunks_exact_mut(4).zip(srcpal.chunks_exact(3)) {
 445                     dclr[..3].copy_from_slice(sclr);
 446                 }
 447                 if let Some(ref mut pkt) = &mut self.pkt {
 448                     pkt.side_data.push(NASideData::Palette(true, Arc::new(pal)));
 449                 }
 450             }
 451             self.sent_pal = true;
 452         }
 453         self.frmcount += 1;
 454         if self.frmcount == self.key_int {
 455             self.frmcount = 0;
 456         }
 457         std::mem::swap(&mut self.frm1, &mut self.frm2);
 458         Ok(())
 459     }
 460     fn get_packet(&mut self) -> EncoderResult<Option<NAPacket>> {
 461         let mut npkt = None;
 462         std::mem::swap(&mut self.pkt, &mut npkt);
 463         Ok(npkt)
 464     }
 465     fn flush(&mut self) -> EncoderResult<()> {
 466         self.frmcount = 0;
 467         Ok(())
 468     }
 469 }
 470
 471 const ENCODER_OPTS: &[NAOptionDefinition] = &[
 472     NAOptionDefinition {
 473         name: KEYFRAME_OPTION, description: KEYFRAME_OPTION_DESC,
 474         opt_type: NAOptionDefinitionType::Int(Some(0), Some(128)) },
 475     NAOptionDefinition {
 476         name: "range", description: "Block search range (0-128)",
 477         opt_type: NAOptionDefinitionType::Int(Some(0), Some(128)) },
 478     NAOptionDefinition {
 479         name: "tile_width", description: "Block width (1-255)",
 480         opt_type: NAOptionDefinitionType::Int(Some(1), Some(255)) },
 481     NAOptionDefinition {
 482         name: "tile_height", description: "Block width (1-255)",
 483         opt_type: NAOptionDefinitionType::Int(Some(1), Some(255)) },
 484     NAOptionDefinition {
 485         name: "compr_level", description: "Compression level",
 486         opt_type: DEFLATE_OPTION_VALUES },
 487 ];
 488
 489 impl NAOptionHandler for ZMBVEncoder {
 490     fn get_supported_options(&self) -> &[NAOptionDefinition] { ENCODER_OPTS }
 491     fn set_options(&mut self, options: &[NAOption]) {
 492         for option in options.iter() {
 493             for opt_def in ENCODER_OPTS.iter() {
 494                 if opt_def.check(option).is_ok() {
 495                     match option.name {
 496                         "compr_level" => {
 497                             if let NAValue::String(ref s) = option.value {
 498                                 if let Ok(val) = s.parse::<DeflateMode>() {
 499                                     self.cmode = val;
 500                                 }
 501                             }
 502                         },
 503                         KEYFRAME_OPTION => {
 504                             if let NAValue::Int(intval) = option.value {
 505                                 self.key_int = intval as u8;
 506                             }
 507                         },
 508                         "range" => {
 509                             if let NAValue::Int(intval) = option.value {
 510                                 self.range = intval as usize;
 511                             }
 512                         },
 513                         "tile_width" => {
 514                             if let NAValue::Int(intval) = option.value {
 515                                 self.tile_w = intval as usize;
 516                             }
 517                         },
 518                         "tile_height" => {
 519                             if let NAValue::Int(intval) = option.value {
 520                                 self.tile_h = intval as usize;
 521                             }
 522                         },
 523                         _ => {},
 524                     };
 525                 }
 526             }
 527         }
 528     }
 529     fn query_option_value(&self, name: &str) -> Option<NAValue> {
 530         match name {
 531             "compr_level" => Some(NAValue::String(self.cmode.to_string())),
 532             KEYFRAME_OPTION => Some(NAValue::Int(i64::from(self.key_int))),
 533             "range"       => Some(NAValue::Int(self.range as i64)),
 534             "tile_width"  => Some(NAValue::Int(self.tile_w as i64)),
 535             "tile_height" => Some(NAValue::Int(self.tile_h as i64)),
 536             _ => None,
 537         }
 538     }
 539 }
 540
 541 pub fn get_encoder() -> Box<dyn NAEncoder + Send> {
 542     Box::new(ZMBVEncoder::new())
 543 }
 544
 545 #[cfg(test)]
 546 mod test {
 547     use nihav_core::codecs::*;
 548     use nihav_core::demuxers::*;
 549     use nihav_core::muxers::*;
 550     use crate::*;
 551     use nihav_codec_support::test::enc_video::*;
 552     use super::{RGB555_FORMAT, RGB24_0_FORMAT};
 553
 554     // samples are from https://samples.mplayerhq.hu/V-codecs/ZMBV/
 555     #[test]
 556     fn test_zmbv_encoder_8bit() {
 557         let mut dmx_reg = RegisteredDemuxers::new();
 558         generic_register_all_demuxers(&mut dmx_reg);
 559         let mut dec_reg = RegisteredDecoders::new();
 560         generic_register_all_decoders(&mut dec_reg);
 561         let mut mux_reg = RegisteredMuxers::new();
 562         generic_register_all_muxers(&mut mux_reg);
 563         let mut enc_reg = RegisteredEncoders::new();
 564         generic_register_all_encoders(&mut enc_reg);
 565
 566         let dec_config = DecoderTestParams {
 567                 demuxer:        "avi",
 568                 in_name:        "assets/Misc/td3_000.avi",
 569                 stream_type:    StreamType::Video,
 570                 limit:          Some(20),
 571                 dmx_reg, dec_reg,
 572             };
 573         let enc_config = EncoderTestParams {
 574                 muxer:          "avi",
 575                 enc_name:       "zmbv",
 576                 out_name:       "zmbv8.avi",
 577                 mux_reg, enc_reg,
 578             };
 579         let dst_vinfo = NAVideoInfo {
 580                 width:   0,
 581                 height:  0,
 582                 format:  PAL8_FORMAT,
 583                 flipped: false,
 584                 bits:    8,
 585             };
 586         let enc_params = EncodeParameters {
 587                 format:  NACodecTypeInfo::Video(dst_vinfo),
 588                 quality: 0,
 589                 bitrate: 0,
 590                 tb_num:  0,
 591                 tb_den:  0,
 592                 flags:   0,
 593             };
 594         let enc_options = &[
 595                 NAOption { name: "range", value: NAValue::Int(16) },
 596             ];
 597         //test_encoding_to_file(&dec_config, &enc_config, enc_params, enc_options);
 598         test_encoding_md5(&dec_config, &enc_config, enc_params, enc_options,
 599                           &[0x08615111, 0x6f644a35, 0xa4e28f32, 0x35d2e66c]);
 600     }
 601
 602     #[test]
 603     fn test_zmbv_encoder_15bit() {
 604         let mut dmx_reg = RegisteredDemuxers::new();
 605         generic_register_all_demuxers(&mut dmx_reg);
 606         let mut dec_reg = RegisteredDecoders::new();
 607         generic_register_all_decoders(&mut dec_reg);
 608         let mut mux_reg = RegisteredMuxers::new();
 609         generic_register_all_muxers(&mut mux_reg);
 610         let mut enc_reg = RegisteredEncoders::new();
 611         generic_register_all_encoders(&mut enc_reg);
 612
 613         let dec_config = DecoderTestParams {
 614                 demuxer:        "avi",
 615                 in_name:        "assets/Misc/zmbv_15bit.avi",
 616                 stream_type:    StreamType::Video,
 617                 limit:          Some(4),
 618                 dmx_reg, dec_reg,
 619             };
 620         let enc_config = EncoderTestParams {
 621                 muxer:          "avi",
 622                 enc_name:       "zmbv",
 623                 out_name:       "zmbv15.avi",
 624                 mux_reg, enc_reg,
 625             };
 626         let dst_vinfo = NAVideoInfo {
 627                 width:   0,
 628                 height:  0,
 629                 format:  RGB555_FORMAT,
 630                 flipped: false,
 631                 bits:    8,
 632             };
 633         let enc_params = EncodeParameters {
 634                 format:  NACodecTypeInfo::Video(dst_vinfo),
 635                 quality: 0,
 636                 bitrate: 0,
 637                 tb_num:  0,
 638                 tb_den:  0,
 639                 flags:   0,
 640             };
 641         let enc_options = &[
 642                 NAOption { name: "range", value: NAValue::Int(16) },
 643             ];
 644         //test_encoding_to_file(&dec_config, &enc_config, enc_params, enc_options);
 645         test_encoding_md5(&dec_config, &enc_config, enc_params, enc_options,
 646                           &[0x1cff4116, 0x5926d91b, 0x60aac53f, 0x8a22bc7b]);
 647     }
 648
 649     #[test]
 650     fn test_zmbv_encoder_16bit() {
 651         let mut dmx_reg = RegisteredDemuxers::new();
 652         generic_register_all_demuxers(&mut dmx_reg);
 653         let mut dec_reg = RegisteredDecoders::new();
 654         generic_register_all_decoders(&mut dec_reg);
 655         let mut mux_reg = RegisteredMuxers::new();
 656         generic_register_all_muxers(&mut mux_reg);
 657         let mut enc_reg = RegisteredEncoders::new();
 658         generic_register_all_encoders(&mut enc_reg);
 659
 660         let dec_config = DecoderTestParams {
 661                 demuxer:        "avi",
 662                 in_name:        "assets/Misc/zmbv_16bit.avi",
 663                 stream_type:    StreamType::Video,
 664                 limit:          Some(4),
 665                 dmx_reg, dec_reg,
 666             };
 667         let enc_config = EncoderTestParams {
 668                 muxer:          "avi",
 669                 enc_name:       "zmbv",
 670                 out_name:       "zmbv16.avi",
 671                 mux_reg, enc_reg,
 672             };
 673         let dst_vinfo = NAVideoInfo {
 674                 width:   0,
 675                 height:  0,
 676                 format:  RGB565_FORMAT,
 677                 flipped: false,
 678                 bits:    8,
 679             };
 680         let enc_params = EncodeParameters {
 681                 format:  NACodecTypeInfo::Video(dst_vinfo),
 682                 quality: 0,
 683                 bitrate: 0,
 684                 tb_num:  0,
 685                 tb_den:  0,
 686                 flags:   0,
 687             };
 688         let enc_options = &[
 689                 NAOption { name: "range", value: NAValue::Int(16) },
 690             ];
 691         //test_encoding_to_file(&dec_config, &enc_config, enc_params, enc_options);
 692         test_encoding_md5(&dec_config, &enc_config, enc_params, enc_options,
 693                           &[0xb48aa633, 0x673539fe, 0xa312d45a, 0x76eee134]);
 694     }
 695
 696     #[test]
 697     fn test_zmbv_encoder_32bit() {
 698         let mut dmx_reg = RegisteredDemuxers::new();
 699         generic_register_all_demuxers(&mut dmx_reg);
 700         let mut dec_reg = RegisteredDecoders::new();
 701         generic_register_all_decoders(&mut dec_reg);
 702         let mut mux_reg = RegisteredMuxers::new();
 703         generic_register_all_muxers(&mut mux_reg);
 704         let mut enc_reg = RegisteredEncoders::new();
 705         generic_register_all_encoders(&mut enc_reg);
 706
 707         let dec_config = DecoderTestParams {
 708                 demuxer:        "avi",
 709                 in_name:        "assets/Misc/zmbv_32bit.avi",
 710                 stream_type:    StreamType::Video,
 711                 limit:          Some(4),
 712                 dmx_reg, dec_reg,
 713             };
 714         let enc_config = EncoderTestParams {
 715                 muxer:          "avi",
 716                 enc_name:       "zmbv",
 717                 out_name:       "zmbv32.avi",
 718                 mux_reg, enc_reg,
 719             };
 720         let dst_vinfo = NAVideoInfo {
 721                 width:   0,
 722                 height:  0,
 723                 format:  RGB24_0_FORMAT,
 724                 flipped: false,
 725                 bits:    8,
 726             };
 727         let enc_params = EncodeParameters {
 728                 format:  NACodecTypeInfo::Video(dst_vinfo),
 729                 quality: 0,
 730                 bitrate: 0,
 731                 tb_num:  0,
 732                 tb_den:  0,
 733                 flags:   0,
 734             };
 735         let enc_options = &[
 736                 NAOption { name: "range", value: NAValue::Int(16) },
 737             ];
 738         //test_encoding_to_file(&dec_config, &enc_config, enc_params, enc_options);
 739         test_encoding_md5(&dec_config, &enc_config, enc_params, enc_options,
 740                           &[0x0836152c, 0xfcd7e1fc, 0xf1e2f619, 0x874d3dbc]);
 741     }
 742 }