nihav-indeo/src/codecs/indeo3enc/mod.rs

   1 use nihav_core::codecs::*;
   2 use nihav_core::io::byteio::*;
   3
   4 mod cell;
   5 use cell::*;
   6 mod mv;
   7 use mv::*;
   8 mod ratectl;
   9 use ratectl::*;
  10 mod tree;
  11 pub use tree::{Indeo3Cell, Plane};
  12 use tree::Indeo3PrimaryTree;
  13
  14 const OS_HEADER_SIZE: usize = 16;
  15 const BITSTREAM_HEADER_SIZE: usize = 48;
  16 const HDR_FIELD_2: u32 = 0;
  17 const FRMH_TAG: u32 = ((b'F' as u32) << 24) | ((b'R' as u32) << 16)
  18                      | ((b'M' as u32) << 8) | (b'H' as u32);
  19 const PLANE_OFFSETS: usize = 32;
  20
  21 const CB_SELECTORS: [u8; 16] = [
  22     0x02, 0x14, 0x26, 0x38, 0x4A, 0x5C, 0x6E, 0x7F,
  23     0x82, 0x94, 0xA6, 0xB8, 0xCA, 0xDC, 0xEE, 0xFF
  24 ];
  25
  26 const PLANE_ORDER: [usize; 3] = [1, 2, 0];
  27
  28 pub struct Indeo3Writer<'a> {
  29     dst:    &'a mut Vec<u8>,
  30     bitbuf: u8,
  31     bits:   u8,
  32     bitpos: Option<usize>,
  33 }
  34
  35 impl<'a> Indeo3Writer<'a> {
  36     fn new(dst: &'a mut Vec<u8>) -> Self {
  37         Self {
  38             dst,
  39             bitbuf: 0,
  40             bits:   0,
  41             bitpos: None,
  42         }
  43     }
  44     pub fn put_byte(&mut self, b: u8) {
  45         self.dst.push(b);
  46     }
  47     pub fn put_2bits(&mut self, val: u8) {
  48         if self.bits == 0 {
  49             self.bitpos = Some(self.dst.len());
  50             self.dst.push(0);
  51         }
  52         self.bitbuf |= val << (6 - self.bits);
  53         self.bits += 2;
  54         if self.bits == 8 {
  55             let bpos = self.bitpos.unwrap_or(0);
  56             self.dst[bpos] = self.bitbuf;
  57             self.bitbuf = 0;
  58             self.bits   = 0;
  59             self.bitpos = None;
  60         }
  61     }
  62 }
  63
  64 impl<'a> Drop for Indeo3Writer<'a> {
  65     fn drop(&mut self) {
  66         if self.bits != 0 {
  67             let bpos = self.bitpos.unwrap_or(0);
  68             self.dst[bpos] = self.bitbuf;
  69         }
  70     }
  71 }
  72
  73 #[derive(Default)]
  74 struct Indeo3Frame {
  75     plane:  [Plane; 3],
  76 }
  77
  78 impl Indeo3Frame {
  79     fn new() -> Self { Self::default() }
  80     fn alloc(&mut self, width: usize, height: usize) {
  81         self.plane[0].alloc(width,     height,     40);
  82         self.plane[1].alloc(width / 4, height / 4, 10);
  83         self.plane[2].alloc(width / 4, height / 4, 10);
  84     }
  85     fn fill(&mut self, vbuf: &NAVideoBufferRef<u8>) {
  86         let data = vbuf.get_data();
  87         for (plane_no, plane) in self.plane.iter_mut().enumerate() {
  88             plane.fill(&data[vbuf.get_offset(plane_no)..], vbuf.get_stride(plane_no));
  89         }
  90     }
  91     fn clear_mvs(&mut self) {
  92         for plane in self.plane.iter_mut() {
  93             plane.clear_mvs();
  94         }
  95     }
  96 }
  97
  98 struct Indeo3Encoder {
  99     stream:     Option<NAStreamRef>,
 100     pkt:        Option<NAPacket>,
 101     cframe:     Indeo3Frame,
 102     pframe:     Indeo3Frame,
 103     cenc:       CellEncoder,
 104     mv_est:     MotionEstimator,
 105     rc:         RateControl,
 106     frameno:    u32,
 107     buf_sel:    bool,
 108     width:      usize,
 109     height:     usize,
 110
 111     debug_tree: bool,
 112     debug_frm:  bool,
 113     try_again:  bool,
 114 }
 115
 116 impl Indeo3Encoder {
 117     fn new() -> Self {
 118         Self {
 119             stream:     None,
 120             pkt:        None,
 121             cframe:     Indeo3Frame::new(),
 122             pframe:     Indeo3Frame::new(),
 123             cenc:       CellEncoder::new(),
 124             mv_est:     MotionEstimator::new(),
 125             rc:         RateControl::new(),
 126             frameno:    0,
 127             buf_sel:    false,
 128             width:      0,
 129             height:     0,
 130
 131             debug_tree: false,
 132             debug_frm:  false,
 133             try_again:  false,
 134         }
 135     }
 136     fn encode_planes(&mut self, dbuf: &mut Vec<u8>, trees: &[Box<Indeo3PrimaryTree>], is_intra: bool) -> EncoderResult<()> {
 137         for (&planeno, tree) in PLANE_ORDER.iter().zip(trees.iter()) {
 138             let offset = dbuf.len();
 139             let ref_plane = &self.pframe.plane[planeno];
 140
 141             let mut mc_count = [0; 4];
 142             let mvs = &self.cframe.plane[planeno].mvs;
 143             write_u32le(&mut mc_count, mvs.len() as u32)?;
 144             dbuf.extend_from_slice(&mc_count);
 145             for &(mv, _) in mvs.iter() {
 146                 dbuf.push(mv.y as u8);
 147                 dbuf.push(mv.x as u8);
 148             }
 149
 150             let mut iw = Indeo3Writer::new(dbuf);
 151             self.cframe.plane[planeno].encode_tree(&mut iw, &tree, &mut self.cenc, is_intra, ref_plane);
 152             drop(iw);
 153             while (dbuf.len() & 3) != 0 {
 154                 dbuf.push(0);
 155             }
 156
 157             let plane_off = PLANE_OFFSETS + 4 * if planeno > 0 { planeno ^ 3 } else { 0 };
 158             write_u32le(&mut dbuf[plane_off..], (offset - OS_HEADER_SIZE) as u32)?;
 159         }
 160
 161         let mut checksum = 0;
 162         for plane in self.cframe.plane.iter() {
 163             checksum ^= plane.checksum();
 164         }
 165         write_u16le(&mut dbuf[26..], checksum)?;
 166
 167         let size = (dbuf.len() - OS_HEADER_SIZE) as u32;
 168         write_u32le(&mut dbuf[8..], self.frameno ^ HDR_FIELD_2 ^ FRMH_TAG ^ size)?;
 169         write_u32le(&mut dbuf[12..], size)?;
 170         write_u32le(&mut dbuf[20..], size * 8)?;
 171
 172         if is_intra {
 173             dbuf.extend_from_slice(b"\x0d\x0aVer 3.99.00.00\x0d\x0a\x00");
 174             while (dbuf.len() & 3) != 0 {
 175                 dbuf.push(0);
 176             }
 177         }
 178
 179         Ok(())
 180     }
 181 }
 182
 183 impl NAEncoder for Indeo3Encoder {
 184     fn negotiate_format(&self, encinfo: &EncodeParameters) -> EncoderResult<EncodeParameters> {
 185         match encinfo.format {
 186             NACodecTypeInfo::None => {
 187                 Ok(EncodeParameters {
 188                         format: NACodecTypeInfo::Video(NAVideoInfo::new(0, 0, true, YUV410_FORMAT)),
 189                         ..Default::default()
 190                     })
 191             },
 192             NACodecTypeInfo::Audio(_) => Err(EncoderError::FormatError),
 193             NACodecTypeInfo::Video(vinfo) => {
 194                 let pix_fmt = YUV410_FORMAT;
 195                 let outinfo = NAVideoInfo::new((vinfo.width + 15) & !15, (vinfo.height + 15) & !15, false, pix_fmt);
 196                 let mut ofmt = *encinfo;
 197                 ofmt.format = NACodecTypeInfo::Video(outinfo);
 198                 Ok(ofmt)
 199             }
 200         }
 201     }
 202     fn init(&mut self, stream_id: u32, encinfo: EncodeParameters) -> EncoderResult<NAStreamRef> {
 203         match encinfo.format {
 204             NACodecTypeInfo::None => Err(EncoderError::FormatError),
 205             NACodecTypeInfo::Audio(_) => Err(EncoderError::FormatError),
 206             NACodecTypeInfo::Video(vinfo) => {
 207                 if vinfo.format != YUV410_FORMAT {
 208                     return Err(EncoderError::FormatError);
 209                 }
 210                 if ((vinfo.width | vinfo.height) & 15) != 0 {
 211                     return Err(EncoderError::FormatError);
 212                 }
 213                 if (vinfo.width > 640) || (vinfo.height > 480) {
 214                     return Err(EncoderError::FormatError);
 215                 }
 216
 217                 self.width  = vinfo.width;
 218                 self.height = vinfo.height;
 219
 220                 let out_info = NAVideoInfo::new(vinfo.width, vinfo.height, false, vinfo.format);
 221                 let info = NACodecInfo::new("indeo3", NACodecTypeInfo::Video(out_info), None);
 222                 let mut stream = NAStream::new(StreamType::Video, stream_id, info, encinfo.tb_num, encinfo.tb_den, 0);
 223                 stream.set_num(stream_id as usize);
 224                 let stream = stream.into_ref();
 225
 226                 self.stream = Some(stream.clone());
 227
 228                 self.cframe.alloc(vinfo.width, vinfo.height);
 229                 self.pframe.alloc(vinfo.width, vinfo.height);
 230
 231                 self.rc.set_bitrate(encinfo.bitrate, encinfo.tb_num, encinfo.tb_den);
 232                 self.rc.set_quality(encinfo.quality);
 233
 234                 Ok(stream)
 235             },
 236         }
 237     }
 238     fn encode(&mut self, frm: &NAFrame) -> EncoderResult<()> {
 239         let buf = frm.get_buffer();
 240         if self.debug_tree || self.debug_frm {
 241             println!("frame {}:", self.frameno);
 242         }
 243
 244         let mut skip_frame = frm.get_frame_type() == FrameType::Skip;
 245         if let NABufferType::None = buf {
 246             skip_frame = true;
 247         }
 248         if skip_frame {
 249             let mut dbuf = Vec::with_capacity(16);
 250             let mut gw   = GrowableMemoryWriter::new_write(&mut dbuf);
 251             let mut bw   = ByteWriter::new(&mut gw);
 252
 253             // OS header
 254             bw.write_u32le(self.frameno)?;
 255             bw.write_u32le(HDR_FIELD_2)?;
 256             bw.write_u32le(0)?; // check
 257             bw.write_u32le(0)?; // size
 258
 259             // bitstream header
 260             bw.write_u16le(32)?; // version
 261             bw.write_u16le(0)?;
 262             bw.write_u32le(0)?; // data size in bits
 263             bw.write_byte(0)?; // cb offset
 264             bw.write_byte(14)?; // reserved
 265             bw.write_u16le(0)?; // checksum
 266             bw.write_u16le(self.height as u16)?;
 267             bw.write_u16le(self.width as u16)?;
 268
 269             let size = (dbuf.len() - OS_HEADER_SIZE) as u32;
 270             write_u32le(&mut dbuf[8..], self.frameno ^ HDR_FIELD_2 ^ FRMH_TAG ^ size)?;
 271             write_u32le(&mut dbuf[12..], size)?;
 272             write_u32le(&mut dbuf[20..], size * 8)?;
 273
 274             let fsize = dbuf.len() as u32;
 275             self.rc.advance(fsize);
 276
 277             self.pkt = Some(NAPacket::new(self.stream.clone().unwrap(), frm.ts, false, dbuf));
 278             return Ok(());
 279         }
 280
 281         if let Some(ref vbuf) = buf.get_vbuf() {
 282             let mut dbuf = Vec::with_capacity(16);
 283             let mut gw   = GrowableMemoryWriter::new_write(&mut dbuf);
 284             let mut bw   = ByteWriter::new(&mut gw);
 285
 286             let (width, height) = vbuf.get_dimensions(0);
 287             if width != self.width || height != self.height {
 288                 self.width  = width;
 289                 self.height = height;
 290                 self.cframe.alloc(width, height);
 291                 self.pframe.alloc(width, height);
 292                 self.rc.reset();
 293             }
 294
 295             let (is_intra, quant) = self.rc.get_quant(self.frameno);
 296             self.cenc.quant = quant;
 297
 298             if is_intra {
 299                 self.buf_sel = false;
 300             } else {
 301                 self.buf_sel = !self.buf_sel;
 302             }
 303
 304             self.cframe.fill(vbuf);
 305             self.cframe.clear_mvs();
 306
 307             // OS header
 308             bw.write_u32le(self.frameno)?;
 309             bw.write_u32le(HDR_FIELD_2)?;
 310             bw.write_u32le(0)?; // check
 311             bw.write_u32le(0)?; // size
 312
 313             // bitstream header
 314             bw.write_u16le(32)?; // version
 315             let mut flags = 0;
 316             if is_intra {
 317                 flags |= 0x5;
 318             } else {
 319                 flags |= 1;
 320                 if self.buf_sel {
 321                     flags |= 1 << 9;
 322                 }
 323             }
 324             bw.write_u16le(flags)?;
 325             bw.write_u32le(0)?; // data size in bits
 326             bw.write_byte(0)?; // cb offset
 327             bw.write_byte(14)?; // reserved
 328             bw.write_u16le(0)?; // checksum
 329             bw.write_u16le(height as u16)?;
 330             bw.write_u16le(width as u16)?;
 331             for _ in 0..3 {
 332                 bw.write_u32le(0)?; // plane data offset
 333             }
 334             bw.write_u32le(0)?; // reserved
 335             bw.write_buf(&CB_SELECTORS)?;
 336
 337             let mut trees = Vec::with_capacity(PLANE_ORDER.len());
 338
 339             // prepare plane data structure
 340             for &planeno in PLANE_ORDER.iter() {
 341                 let ref_plane = &self.pframe.plane[planeno];
 342                 let tree = self.cframe.plane[planeno].find_cells(is_intra, ref_plane, &self.mv_est);
 343                 if self.debug_tree {
 344                     println!(" tree for plane {}:", planeno);
 345                     tree.print();
 346                 }
 347                 trees.push(tree);
 348                 let mvs = &mut self.cframe.plane[planeno].mvs;
 349                 compact_mvs(mvs);
 350             }
 351
 352             self.encode_planes(&mut dbuf, &trees, is_intra)?;
 353
 354             let cur_quant = self.cenc.quant.unwrap_or(42);
 355             if !is_intra && cur_quant < 8 {
 356                 let expected_size = self.rc.get_expected_size();
 357                 if expected_size > 0 {
 358                     let cur_size = dbuf.len() as u32;
 359                     // try re-encoding frame if possible
 360                     if cur_size > expected_size * 3 / 2 {
 361                         self.cframe.fill(vbuf);
 362                         let new_quant = if cur_quant < 7 {
 363                                 cur_quant + 1
 364                             } else {
 365                                 cur_quant - 1
 366                             };
 367                         self.cenc.quant = Some(new_quant);
 368                         dbuf.truncate(OS_HEADER_SIZE + BITSTREAM_HEADER_SIZE);
 369                         self.encode_planes(&mut dbuf, &trees, is_intra)?;
 370                     }
 371                 }
 372             }
 373
 374             if self.debug_frm {
 375                 for plane in self.cframe.plane.iter() {
 376                     for (y, line) in plane.data.chunks(plane.width).enumerate() {
 377                         print!(" {:3}:", y);
 378                         for &el in line.iter() { print!(" {:02X}", el); }
 379                         println!();
 380                     }
 381                     println!();
 382                 }
 383             }
 384
 385             std::mem::swap(&mut self.cframe, &mut self.pframe);
 386             self.frameno += 1;
 387
 388             let fsize = dbuf.len() as u32;
 389             self.rc.advance(fsize);
 390
 391             self.pkt = Some(NAPacket::new(self.stream.clone().unwrap(), frm.ts, is_intra, dbuf));
 392             Ok(())
 393         } else {
 394             Err(EncoderError::InvalidParameters)
 395         }
 396     }
 397     fn get_packet(&mut self) -> EncoderResult<Option<NAPacket>> {
 398         let mut npkt = None;
 399         std::mem::swap(&mut self.pkt, &mut npkt);
 400         Ok(npkt)
 401     }
 402     fn flush(&mut self) -> EncoderResult<()> {
 403         Ok(())
 404     }
 405 }
 406
 407 const DEBUG_TREE_OPTION: &str = "debug_tree";
 408 const DEBUG_FRAME_OPTION: &str = "debug_frame";
 409 const MV_RANGE_OPTION: &str = "mv_range";
 410 const MV_FLAT_OPTION: &str = "mv_flat_threshold";
 411 const MV_THRESHOLD_OPTION: &str = "mv_threshold";
 412 const CELL_I_THRESHOLD_OPTION: &str = "cell_i_threshold";
 413 const CELL_P_THRESHOLD_OPTION: &str = "cell_p_threshold";
 414 const DO_RLE_OPTION: &str = "rle";
 415 const TRY_AGAIN_OPTION: &str = "try_recompress";
 416
 417 const ENCODER_OPTS: &[NAOptionDefinition] = &[
 418     NAOptionDefinition {
 419         name: KEYFRAME_OPTION, description: KEYFRAME_OPTION_DESC,
 420         opt_type: NAOptionDefinitionType::Int(Some(0), Some(128)) },
 421     NAOptionDefinition {
 422         name: DEBUG_TREE_OPTION, description: "Print frame trees",
 423         opt_type: NAOptionDefinitionType::Bool },
 424     NAOptionDefinition {
 425         name: DEBUG_FRAME_OPTION, description: "Print encoder-reconstructed frames",
 426         opt_type: NAOptionDefinitionType::Bool },
 427     NAOptionDefinition {
 428         name: MV_RANGE_OPTION, description: "Motion search range",
 429         opt_type: NAOptionDefinitionType::Int(Some(0), Some(120)) },
 430     NAOptionDefinition {
 431         name: MV_FLAT_OPTION, description: "Threshold for coding cell as skipped one",
 432         opt_type: NAOptionDefinitionType::Int(Some(0), Some(1000)) },
 433     NAOptionDefinition {
 434         name: MV_THRESHOLD_OPTION, description: "Threshold for coding cell as inter",
 435         opt_type: NAOptionDefinitionType::Int(Some(0), Some(1000)) },
 436     NAOptionDefinition {
 437         name: CELL_I_THRESHOLD_OPTION, description: "Threshold for coding intra block as flat",
 438         opt_type: NAOptionDefinitionType::Int(Some(0), Some(128)) },
 439     NAOptionDefinition {
 440         name: CELL_P_THRESHOLD_OPTION, description: "Threshold for coding inter cell in coarser mode",
 441         opt_type: NAOptionDefinitionType::Int(Some(0), Some(128)) },
 442     NAOptionDefinition {
 443         name: DO_RLE_OPTION, description: "Perform zero run length compation",
 444         opt_type: NAOptionDefinitionType::Bool },
 445     NAOptionDefinition {
 446         name: TRY_AGAIN_OPTION, description: "Try compressing the frame again for the better bitrate fit",
 447         opt_type: NAOptionDefinitionType::Bool },
 448 ];
 449
 450 impl NAOptionHandler for Indeo3Encoder {
 451     fn get_supported_options(&self) -> &[NAOptionDefinition] { ENCODER_OPTS }
 452     fn set_options(&mut self, options: &[NAOption]) {
 453         for option in options.iter() {
 454             for opt_def in ENCODER_OPTS.iter() {
 455                 if opt_def.check(option).is_ok() {
 456                     match option.name {
 457                         KEYFRAME_OPTION => {
 458                             if let NAValue::Int(val) = option.value {
 459                                 self.rc.set_key_int(val as u32);
 460                             }
 461                         },
 462                         DEBUG_TREE_OPTION => {
 463                             if let NAValue::Bool(val) = option.value {
 464                                 self.debug_tree = val;
 465                             }
 466                         },
 467                         DEBUG_FRAME_OPTION => {
 468                             if let NAValue::Bool(val) = option.value {
 469                                 self.debug_frm = val;
 470                             }
 471                         },
 472                         MV_RANGE_OPTION => {
 473                             if let NAValue::Int(val) = option.value {
 474                                 self.mv_est.mv_range = val as i8;
 475                             }
 476                         },
 477                         MV_FLAT_OPTION => {
 478                             if let NAValue::Int(val) = option.value {
 479                                 self.mv_est.flat_thr = val as u16;
 480                             }
 481                         },
 482                         MV_THRESHOLD_OPTION => {
 483                             if let NAValue::Int(val) = option.value {
 484                                 self.mv_est.mv_thr = val as u16;
 485                             }
 486                         },
 487                         CELL_I_THRESHOLD_OPTION => {
 488                             if let NAValue::Int(val) = option.value {
 489                                 self.cenc.flat_thr_i = val as u32;
 490                             }
 491                         },
 492                         CELL_P_THRESHOLD_OPTION => {
 493                             if let NAValue::Int(val) = option.value {
 494                                 self.cenc.flat_thr_p = val as u32;
 495                             }
 496                         },
 497                         DO_RLE_OPTION => {
 498                             if let NAValue::Bool(val) = option.value {
 499                                 self.cenc.do_rle = val;
 500                             }
 501                         },
 502                         TRY_AGAIN_OPTION => {
 503                             if let NAValue::Bool(val) = option.value {
 504                                 self.try_again = val;
 505                             }
 506                         },
 507                         _ => {},
 508                     };
 509                 }
 510             }
 511         }
 512     }
 513     fn query_option_value(&self, name: &str) -> Option<NAValue> {
 514         match name {
 515             KEYFRAME_OPTION => Some(NAValue::Int(i64::from(self.rc.get_key_int()))),
 516             DEBUG_TREE_OPTION => Some(NAValue::Bool(self.debug_tree)),
 517             DEBUG_FRAME_OPTION => Some(NAValue::Bool(self.debug_frm)),
 518             MV_RANGE_OPTION => Some(NAValue::Int(i64::from(self.mv_est.mv_range))),
 519             MV_FLAT_OPTION => Some(NAValue::Int(i64::from(self.mv_est.flat_thr))),
 520             MV_THRESHOLD_OPTION => Some(NAValue::Int(i64::from(self.mv_est.mv_thr))),
 521             CELL_I_THRESHOLD_OPTION => Some(NAValue::Int(i64::from(self.cenc.flat_thr_i))),
 522             CELL_P_THRESHOLD_OPTION => Some(NAValue::Int(i64::from(self.cenc.flat_thr_p))),
 523             DO_RLE_OPTION => Some(NAValue::Bool(self.cenc.do_rle)),
 524             TRY_AGAIN_OPTION => Some(NAValue::Bool(self.try_again)),
 525             _ => None,
 526         }
 527     }
 528 }
 529
 530 pub fn get_encoder() -> Box<dyn NAEncoder + Send> {
 531     Box::new(Indeo3Encoder::new())
 532 }
 533
 534 #[cfg(test)]
 535 mod test {
 536     use crate::*;
 537     use nihav_core::codecs::*;
 538     use nihav_core::demuxers::*;
 539     use nihav_core::muxers::*;
 540     use nihav_commonfmt::*;
 541     use nihav_codec_support::test::enc_video::*;
 542
 543     #[allow(unused_variables)]
 544     fn encode_test(name: &'static str, enc_options: &[NAOption], limit: Option<u64>, hash: &[u32; 4]) {
 545         let mut dmx_reg = RegisteredDemuxers::new();
 546         generic_register_all_demuxers(&mut dmx_reg);
 547         let mut dec_reg = RegisteredDecoders::new();
 548         indeo_register_all_decoders(&mut dec_reg);
 549         let mut mux_reg = RegisteredMuxers::new();
 550         generic_register_all_muxers(&mut mux_reg);
 551         let mut enc_reg = RegisteredEncoders::new();
 552         indeo_register_all_encoders(&mut enc_reg);
 553
 554         let dec_config = DecoderTestParams {
 555                 demuxer:        "avi",
 556                 in_name:        "assets/Indeo/laser05.avi",
 557                 stream_type:    StreamType::Video,
 558                 limit,
 559                 dmx_reg, dec_reg,
 560             };
 561         let enc_config = EncoderTestParams {
 562                 muxer:          "avi",
 563                 enc_name:       "indeo3",
 564                 out_name:       name,
 565                 mux_reg, enc_reg,
 566             };
 567         let dst_vinfo = NAVideoInfo {
 568                 width:   0,
 569                 height:  0,
 570                 format:  YUV410_FORMAT,
 571                 flipped: false,
 572                 bits:    9,
 573             };
 574         let enc_params = EncodeParameters {
 575                 format:  NACodecTypeInfo::Video(dst_vinfo),
 576                 quality: 0,
 577                 bitrate: 25000 * 8,
 578                 tb_num:  0,
 579                 tb_den:  0,
 580                 flags:   0,
 581             };
 582         //test_encoding_to_file(&dec_config, &enc_config, enc_params, enc_options);
 583         test_encoding_md5(&dec_config, &enc_config, enc_params, enc_options, hash);
 584     }
 585     #[test]
 586     fn test_indeo3_encoder1() {
 587         let enc_options = &[
 588                 NAOption { name: super::TRY_AGAIN_OPTION, value: NAValue::Bool(true) },
 589             ];
 590         encode_test("indeo3.avi", enc_options, Some(4), &[0x4cc927d3, 0x9872f824, 0x92dee9cb, 0xaf912ecc]);
 591     }
 592     /*#[test]
 593     fn test_indeo3_roundtrip() {
 594         const YPATTERN: [u8; 16] = [32, 72, 40, 106, 80, 20, 33, 58, 77, 140, 121, 100, 83, 57, 30, 11];
 595         const CPATTERN: [u8; 4] = [0x80; 4];
 596
 597         let dst_vinfo = NAVideoInfo {
 598                 width:   16,
 599                 height:  16,
 600                 format:  YUV410_FORMAT,
 601                 flipped: false,
 602                 bits:    9,
 603             };
 604         let enc_params = EncodeParameters {
 605                 format:  NACodecTypeInfo::Video(dst_vinfo),
 606                 quality: 0,
 607                 bitrate: 0,
 608                 tb_num:  0,
 609                 tb_den:  0,
 610                 flags:   0,
 611             };
 612
 613         let mut ienc = super::get_encoder();
 614         ienc.init(0, enc_params).unwrap();
 615         let mut buffer = alloc_video_buffer(dst_vinfo, 2).unwrap();
 616         if let NABufferType::Video(ref mut buf) = buffer {
 617             let vbuf = NASimpleVideoFrame::from_video_buf(buf).unwrap();
 618             for i in 0..16 {
 619                 vbuf.data[vbuf.offset[0] + i * vbuf.stride[0]..][..16].copy_from_slice(&YPATTERN);
 620             }
 621             for plane in 1..3 {
 622                 for i in 0..4 {
 623                     vbuf.data[vbuf.offset[plane] + i * vbuf.stride[plane]..][..4].copy_from_slice(&CPATTERN);
 624                 }
 625             }
 626         }
 627         let info = NACodecInfo::new("indeo3", NACodecTypeInfo::Video(dst_vinfo), None).into_ref();
 628         let frm = NAFrame::new(NATimeInfo::new(Some(0), None, None, 1, 12), FrameType::I, true, info.clone(), buffer);
 629         ienc.encode(&frm).unwrap();
 630         let pkt = ienc.get_packet().unwrap().unwrap();
 631         println!(" pkt size {}", pkt.get_buffer().len());
 632
 633         let mut dec_reg = RegisteredDecoders::new();
 634         indeo_register_all_decoders(&mut dec_reg);
 635         let decfunc = dec_reg.find_decoder("indeo3").unwrap();
 636         let mut dec = (decfunc)();
 637         let mut dsupp = Box::new(NADecoderSupport::new());
 638         dec.init(&mut dsupp, info).unwrap();
 639         let dst = dec.decode(&mut dsupp, &pkt).unwrap();
 640         if let NABufferType::Video(ref vbuf) = dst.get_buffer() {
 641             for plane in 0..3 {
 642                 let size = if plane == 0 { 16 } else { 4 };
 643                 let start = vbuf.get_offset(plane);
 644                 for line in vbuf.get_data()[start..].chunks(vbuf.get_stride(plane)).take(size) {
 645                     print!("   ");
 646                     for &el in line[..size].iter() {
 647                         print!(" {:02X}", el >> 1);
 648                     }
 649                     println!();
 650                 }
 651                 if plane == 0 {
 652                     print!("ref");
 653                     for &el in YPATTERN.iter() { print!(" {:02X}", el >> 1); } println!();
 654                 }
 655                 println!();
 656             }
 657         }
 658         panic!("end");
 659     }*/
 660 }