nihav-commonfmt/src/codecs/cinepakenc.rs

   1 use nihav_core::codecs::*;
   2 use nihav_core::io::byteio::*;
   3 use nihav_codec_support::vq::*;
   4
   5 #[derive(Default,Clone,Copy,PartialEq,Debug)]
   6 struct YUVCode {
   7     y:  [u8; 4],
   8     u:  u8,
   9     v:  u8,
  10 }
  11 impl VQElement for YUVCode {
  12     fn dist(&self, rval: Self) -> u32 {
  13         let mut ysum = 0;
  14         for (y0, y1) in self.y.iter().zip(rval.y.iter()) {
  15             let yd = i32::from(*y0) - i32::from(*y1);
  16             ysum += yd * yd;
  17         }
  18         let ud = i32::from(self.u) - i32::from(rval.u);
  19         let vd = i32::from(self.v) - i32::from(rval.v);
  20         (ysum + ud * ud + vd * vd) as u32
  21     }
  22     fn min_cw() -> Self { YUVCode { y: [0; 4], u: 0, v: 0 } }
  23     fn max_cw() -> Self { YUVCode { y: [255; 4], u: 255, v: 255 } }
  24     fn min(&self, rval: Self) -> Self {
  25         let mut ycode = YUVCode::default();
  26         for i in 0..4 {
  27             ycode.y[i] = self.y[i].min(rval.y[i]);
  28         }
  29         ycode.u = self.u.min(rval.u);
  30         ycode.v = self.v.min(rval.v);
  31         ycode
  32     }
  33     fn max(&self, rval: Self) -> Self {
  34         let mut ycode = YUVCode::default();
  35         for i in 0..4 {
  36             ycode.y[i] = self.y[i].max(rval.y[i]);
  37         }
  38         ycode.u = self.u.max(rval.u);
  39         ycode.v = self.v.max(rval.v);
  40         ycode
  41     }
  42     fn num_components() -> usize { 6 }
  43     fn sort_by_component(arr: &mut [Self], component: usize) {
  44         let mut counts = [0; 256];
  45         for entry in arr.iter() {
  46             let idx = match component {
  47                     0 | 1 | 2 | 3 => entry.y[component],
  48                     4 => entry.u,
  49                     _ => entry.v,
  50                 } as usize;
  51             counts[idx] += 1;
  52         }
  53         let mut offs = [0; 256];
  54         for i in 0..255 {
  55             offs[i + 1] = offs[i] + counts[i];
  56         }
  57         let mut dst = vec![YUVCode::default(); arr.len()];
  58         for entry in arr.iter() {
  59             let idx = match component {
  60                     0 | 1 | 2 | 3 => entry.y[component],
  61                     4 => entry.u,
  62                     _ => entry.v,
  63                 } as usize;
  64             dst[offs[idx]] = *entry;
  65             offs[idx] += 1;
  66         }
  67         arr.copy_from_slice(dst.as_slice());
  68     }
  69     fn max_dist_component(min: &Self, max: &Self) -> usize {
  70         let mut comp = 0;
  71         let mut diff = 0;
  72         for i in 0..4 {
  73             let d = u32::from(max.y[i]) - u32::from(min.y[i]);
  74             if d > diff {
  75                 diff = d;
  76                 comp = i;
  77             }
  78         }
  79         let ud = u32::from(max.u) - u32::from(min.u);
  80         if ud > diff {
  81             diff = ud;
  82             comp = 4;
  83         }
  84         let vd = u32::from(max.v) - u32::from(min.v);
  85         if vd > diff {
  86             comp = 5;
  87         }
  88         comp
  89     }
  90 }
  91
  92 #[derive(Default)]
  93 struct YUVCodeSum {
  94     ysum:   [u64; 4],
  95     usum:   u64,
  96     vsum:   u64,
  97     count:  u64,
  98 }
  99
 100 impl VQElementSum<YUVCode> for YUVCodeSum {
 101     fn zero() -> Self { Self::default() }
 102     fn add(&mut self, rval: YUVCode, count: u64) {
 103         for i in 0..4 {
 104             self.ysum[i] += u64::from(rval.y[i]) * count;
 105         }
 106         self.usum += u64::from(rval.u) * count;
 107         self.vsum += u64::from(rval.v) * count;
 108         self.count += count;
 109     }
 110     fn get_centroid(&self) -> YUVCode {
 111         if self.count != 0 {
 112             let mut ycode = YUVCode::default();
 113             for i in 0..4 {
 114                 ycode.y[i] = ((self.ysum[i] + self.count / 2) / self.count) as u8;
 115             }
 116             ycode.u = ((self.usum + self.count / 2) / self.count) as u8;
 117             ycode.v = ((self.vsum + self.count / 2) / self.count) as u8;
 118             ycode
 119         } else {
 120             YUVCode::default()
 121         }
 122     }
 123 }
 124
 125 struct RNG {
 126     seed: u32,
 127 }
 128
 129 impl RNG {
 130     fn new() -> Self { Self { seed: 0x12345678 } }
 131     fn next(&mut self) -> u8 {
 132         let mut x = self.seed;
 133         x ^= x.wrapping_shl(13);
 134         x ^= x >> 17;
 135         self.seed = x;
 136         (self.seed >> 24) as u8
 137     }
 138     fn fill_entry(&mut self, entry: &mut YUVCode) {
 139         for y in entry.y.iter_mut() {
 140             *y = self.next();
 141         }
 142         entry.u = self.next();
 143         entry.v = self.next();
 144     }
 145 }
 146
 147 const GRAY_FORMAT: NAPixelFormaton = NAPixelFormaton {
 148         model: ColorModel::YUV(YUVSubmodel::YUVJ),
 149         components: 1,
 150         comp_info: [Some(NAPixelChromaton{h_ss: 0, v_ss: 0, packed: false, depth: 8, shift: 0, comp_offs: 0, next_elem: 1}), None, None, None, None],
 151         elem_size: 1,
 152         be: true,
 153         alpha: false,
 154         palette: false,
 155     };
 156
 157 struct MaskWriter {
 158     masks:  Vec<u32>,
 159     mask:   u32,
 160     pos:    u8,
 161 }
 162
 163 impl MaskWriter {
 164     fn new() -> Self {
 165         Self {
 166             masks:  Vec::new(),
 167             mask:   0,
 168             pos:    0,
 169         }
 170     }
 171     fn reset(&mut self) {
 172         self.masks.clear();
 173         self.mask = 0;
 174         self.pos = 0;
 175     }
 176     fn put_v1(&mut self) {
 177         self.mask <<= 1;
 178         self.pos += 1;
 179         if self.pos == 32 {
 180             self.flush();
 181         }
 182     }
 183     fn put_v4(&mut self) {
 184         self.mask <<= 1;
 185         self.mask  |= 1;
 186         self.pos += 1;
 187         if self.pos == 32 {
 188             self.flush();
 189         }
 190     }
 191     fn put_inter(&mut self, skip: bool) {
 192         self.mask <<= 1;
 193         self.mask  |= !skip as u32;
 194         self.pos += 1;
 195         if self.pos == 32 {
 196             self.flush();
 197         }
 198     }
 199     fn flush(&mut self) {
 200         self.masks.push(self.mask);
 201         self.mask = 0;
 202         self.pos = 0;
 203     }
 204     fn end(&mut self) {
 205         if self.pos == 0 { return; }
 206         while self.pos < 32 {
 207             self.mask <<= 1;
 208             self.pos += 1;
 209         }
 210         self.flush();
 211     }
 212 }
 213
 214 #[derive(Clone,Copy,PartialEq)]
 215 enum QuantMode {
 216     ELBG,
 217     MedianCut,
 218 }
 219
 220 impl std::string::ToString for QuantMode {
 221     fn to_string(&self) -> String {
 222         match *self {
 223             QuantMode::ELBG => "elbg".to_string(),
 224             QuantMode::MedianCut => "mediancut".to_string(),
 225         }
 226     }
 227 }
 228
 229 struct CinepakEncoder {
 230     stream:     Option<NAStreamRef>,
 231     lastfrm:    Option<NAVideoBufferRef<u8>>,
 232     pkt:        Option<NAPacket>,
 233     frmcount:   u8,
 234     key_int:    u8,
 235     qmode:      QuantMode,
 236     quality:    u8,
 237     nstrips:    usize,
 238     force_v1:   bool,
 239     cur_strip:  usize,
 240     v1_entries: Vec<YUVCode>,
 241     v4_entries: Vec<YUVCode>,
 242     v1_cb:      Vec<[YUVCode; 256]>,
 243     v4_cb:      Vec<[YUVCode; 256]>,
 244     v1_cur_cb:  Vec<[YUVCode; 256]>,
 245     v4_cur_cb:  Vec<[YUVCode; 256]>,
 246     v1_len:     usize,
 247     v4_len:     usize,
 248     v1_idx:     Vec<u8>,
 249     v4_idx:     Vec<u8>,
 250     grayscale:  bool,
 251     rng:        RNG,
 252     masks:      MaskWriter,
 253     skip_dist:  Vec<u32>,
 254 }
 255
 256 fn avg4(a: u8, b: u8, c: u8, d: u8) -> u8 {
 257     ((u16::from(a) + u16::from(b) + u16::from(c) + u16::from(d) + 3) >> 2) as u8
 258 }
 259
 260 fn patch_size(bw: &mut ByteWriter, pos: u64) -> EncoderResult<()> {
 261     let size = bw.tell() - pos;
 262     bw.seek(SeekFrom::Current(-((size + 3) as i64)))?;
 263     bw.write_u24be((size + 4) as u32)?;
 264     bw.seek(SeekFrom::End(0))?;
 265     Ok(())
 266 }
 267
 268 impl CinepakEncoder {
 269     fn new() -> Self {
 270         Self {
 271             stream:     None,
 272             pkt:        None,
 273             lastfrm:    None,
 274             frmcount:   0,
 275             qmode:      QuantMode::MedianCut,
 276             key_int:    25,
 277             quality:    0,
 278             nstrips:    2,
 279             force_v1:   false,
 280             cur_strip:  0,
 281             v1_entries: Vec::new(),
 282             v4_entries: Vec::new(),
 283             v1_cb:      Vec::with_capacity(2),
 284             v4_cb:      Vec::with_capacity(2),
 285             v1_cur_cb:  Vec::with_capacity(2),
 286             v4_cur_cb:  Vec::with_capacity(2),
 287             v1_len:     0,
 288             v4_len:     0,
 289             grayscale:  false,
 290             rng:        RNG::new(),
 291             v1_idx:     Vec::new(),
 292             v4_idx:     Vec::new(),
 293             masks:      MaskWriter::new(),
 294             skip_dist:  Vec::new(),
 295         }
 296     }
 297     fn read_strip(&mut self, in_frm: &NAVideoBuffer<u8>, start: usize, end: usize) {
 298         let ystride  = in_frm.get_stride(0);
 299         let mut yoff = in_frm.get_offset(0) + start * ystride;
 300         let ustride  = in_frm.get_stride(1);
 301         let mut uoff = in_frm.get_offset(1) + start / 2 * ustride;
 302         let vstride  = in_frm.get_stride(2);
 303         let mut voff = in_frm.get_offset(2) + start / 2 * vstride;
 304         let (width, _) = in_frm.get_dimensions(0);
 305         let data = in_frm.get_data();
 306         self.v1_entries.clear();
 307         self.v4_entries.clear();
 308         for _ in (start..end).step_by(4) {
 309             for x in (0..width).step_by(4) {
 310                 let mut yblk = [0; 16];
 311                 let mut ublk = [128; 4];
 312                 let mut vblk = [128; 4];
 313                 for j in 0..4 {
 314                     for i in 0..4 {
 315                         yblk[i + j * 4] = data[yoff + x + i + j * ystride];
 316                     }
 317                 }
 318                 if !self.grayscale {
 319                     for j in 0..2 {
 320                         for i in 0..2 {
 321                             ublk[i + j * 2] = data[uoff + x / 2 + i + j * ustride];
 322                             vblk[i + j * 2] = data[voff + x / 2 + i + j * vstride];
 323                         }
 324                     }
 325                 }
 326                 self.v1_entries.push(YUVCode {
 327                         y: [avg4(yblk[ 0], yblk[ 1], yblk[ 4], yblk[ 5]),
 328                             avg4(yblk[ 2], yblk[ 3], yblk[ 6], yblk[ 7]),
 329                             avg4(yblk[ 8], yblk[ 9], yblk[12], yblk[13]),
 330                             avg4(yblk[10], yblk[11], yblk[14], yblk[15])],
 331                         u: avg4(ublk[0], ublk[1], ublk[2], ublk[3]),
 332                         v: avg4(vblk[0], vblk[1], vblk[2], vblk[3]),
 333                     });
 334                 for i in 0..4 {
 335                     let yidx = (i & 1) * 2 + (i & 2) * 4;
 336                     self.v4_entries.push(YUVCode {
 337                             y: [ yblk[yidx], yblk[yidx + 1], yblk[yidx + 4], yblk[yidx + 5] ],
 338                             u: ublk[i],
 339                             v: vblk[i],
 340                         });
 341                 }
 342             }
 343             yoff += ystride * 4;
 344             uoff += ustride * 2;
 345             voff += vstride * 2;
 346         }
 347     }
 348     fn find_nearest(codebook: &[YUVCode], code: YUVCode) -> (u8, u32) {
 349         let mut min_dist = std::u32::MAX;
 350         let mut idx = 0;
 351         for (i, cw) in codebook.iter().enumerate() {
 352             let dist = cw.dist(code);
 353             if dist < min_dist {
 354                 min_dist = dist;
 355                 idx = i;
 356                 if dist == 0 {
 357                     break;
 358                 }
 359             }
 360         }
 361         (idx as u8, min_dist)
 362     }
 363     fn can_update_cb(new_cb: &[YUVCode], old_cb: &[YUVCode], cb_size: usize) -> bool {
 364         let mut skip_count = 0;
 365         for (new, old) in new_cb.iter().zip(old_cb.iter()) {
 366             if new == old {
 367                 skip_count += 1;
 368             }
 369         }
 370         let full_size = cb_size * new_cb.len();
 371         let upd_size = cb_size * (new_cb.len() - skip_count) + (new_cb.len() + 31) / 32 * 4;
 372         upd_size < full_size
 373     }
 374     fn write_cb(bw: &mut ByteWriter, mut id: u8, new_cb: &[YUVCode], old_cb: &[YUVCode], grayscale: bool, update: bool, num_elem: usize) -> EncoderResult<()> {
 375         if grayscale {
 376             id |= 4;
 377         }
 378         if update {
 379             id |= 1;
 380         }
 381         bw.write_byte(id)?;
 382         bw.write_u24be(0)?;
 383         let chunk_pos = bw.tell();
 384         if !update {
 385             for entry in new_cb.iter().take(num_elem) {
 386                 bw.write_buf(&entry.y)?;
 387                 if !grayscale {
 388                     bw.write_byte(entry.u ^ 0x80)?;
 389                     bw.write_byte(entry.v ^ 0x80)?;
 390                 }
 391             }
 392         } else {
 393             let mut end = num_elem;
 394             for (i, (ncw, ocw)) in new_cb.iter().zip(old_cb.iter()).enumerate().take(num_elem).rev() {
 395                 if ncw == ocw {
 396                     end = i;
 397                 } else {
 398                     break;
 399                 }
 400             }
 401             for i in (0..end).step_by(32) {
 402                 let mut mask = 0;
 403                 for j in 0..32 {
 404                     mask <<= 1;
 405                     if new_cb[i + j] != old_cb[i + j] {
 406                         mask |= 1;
 407                     }
 408                 }
 409                 bw.write_u32be(mask)?;
 410                 for j in 0..32 {
 411                     if new_cb[i + j] == old_cb[i + j] { continue; }
 412                     bw.write_buf(&new_cb[i + j].y)?;
 413                     if !grayscale {
 414                         bw.write_byte(new_cb[i + j].u ^ 0x80)?;
 415                         bw.write_byte(new_cb[i + j].v ^ 0x80)?;
 416                     }
 417                 }
 418             }
 419         }
 420         patch_size(bw, chunk_pos)?;
 421         Ok(())
 422     }
 423     fn render_stripe(&mut self, intra: bool, start: usize, end: usize) {
 424         if let Some(ref mut dst_frm) = self.lastfrm {
 425             let ystride  = dst_frm.get_stride(0);
 426             let mut yoff = dst_frm.get_offset(0) + start * ystride;
 427             let ustride  = dst_frm.get_stride(1);
 428             let mut uoff = dst_frm.get_offset(1) + start / 2 * ustride;
 429             let vstride  = dst_frm.get_stride(2);
 430             let mut voff = dst_frm.get_offset(2) + start / 2 * vstride;
 431             let (width, _) = dst_frm.get_dimensions(0);
 432             let data = dst_frm.get_data_mut().unwrap();
 433             let mut miter = self.masks.masks.iter();
 434             let mut v1_iter = self.v1_idx.iter();
 435             let mut v4_iter = self.v4_idx.iter();
 436             let mut cur_mask = 0;
 437             let mut cur_bit = 0;
 438             for _ in (start..end).step_by(4) {
 439                 for x in (0..width).step_by(4) {
 440                     if cur_bit == 0 {
 441                         if !intra || !self.v1_idx.is_empty() {
 442                             cur_mask = *miter.next().unwrap();
 443                         } else {
 444                             cur_mask = 0xFFFFFFFF;
 445                         }
 446                         cur_bit = 1 << 31;
 447                     }
 448                     if !intra {
 449                         if (cur_mask & cur_bit) == 0 {
 450                             cur_bit >>= 1;
 451                             continue;
 452                         }
 453                         cur_bit >>= 1;
 454                         if cur_bit == 0 {
 455                             cur_mask = *miter.next().unwrap();
 456                             cur_bit = 1 << 31;
 457                         }
 458                     }
 459                     if (cur_mask & cur_bit) == 0 {
 460                         let idx = *v1_iter.next().unwrap() as usize;
 461                         let cb = &self.v1_cur_cb[self.cur_strip][idx];
 462
 463                         let mut coff = yoff + x;
 464                         data[coff]     = cb.y[0]; data[coff + 1] = cb.y[0];
 465                         data[coff + 2] = cb.y[1]; data[coff + 3] = cb.y[1];
 466                         coff += ystride;
 467                         data[coff]     = cb.y[0]; data[coff + 1] = cb.y[0];
 468                         data[coff + 2] = cb.y[1]; data[coff + 3] = cb.y[1];
 469                         coff += ystride;
 470                         data[coff]     = cb.y[2]; data[coff + 1] = cb.y[2];
 471                         data[coff + 2] = cb.y[3]; data[coff + 3] = cb.y[3];
 472                         coff += ystride;
 473                         data[coff]     = cb.y[2]; data[coff + 1] = cb.y[2];
 474                         data[coff + 2] = cb.y[3]; data[coff + 3] = cb.y[3];
 475
 476                         if !self.grayscale {
 477                             let mut coff = uoff + x / 2;
 478                             data[coff] = cb.u; data[coff + 1] = cb.u;
 479                             coff += ustride;
 480                             data[coff] = cb.u; data[coff + 1] = cb.u;
 481
 482                             let mut coff = voff + x / 2;
 483                             data[coff] = cb.v; data[coff + 1] = cb.v;
 484                             coff += vstride;
 485                             data[coff] = cb.v; data[coff + 1] = cb.v;
 486                         }
 487                     } else {
 488                         let idx0 = *v4_iter.next().unwrap() as usize;
 489                         let cb0 = &self.v4_cur_cb[self.cur_strip][idx0];
 490                         let idx1 = *v4_iter.next().unwrap() as usize;
 491                         let cb1 = &self.v4_cur_cb[self.cur_strip][idx1];
 492                         let idx2 = *v4_iter.next().unwrap() as usize;
 493                         let cb2 = &self.v4_cur_cb[self.cur_strip][idx2];
 494                         let idx3 = *v4_iter.next().unwrap() as usize;
 495                         let cb3 = &self.v4_cur_cb[self.cur_strip][idx3];
 496
 497                         let mut coff = yoff + x;
 498                         data[coff]     = cb0.y[0]; data[coff + 1] = cb0.y[1];
 499                         data[coff + 2] = cb1.y[0]; data[coff + 3] = cb1.y[1];
 500                         coff += ystride;
 501                         data[coff]     = cb0.y[2]; data[coff + 1] = cb0.y[3];
 502                         data[coff + 2] = cb1.y[2]; data[coff + 3] = cb1.y[3];
 503                         coff += ystride;
 504                         data[coff]     = cb2.y[0]; data[coff + 1] = cb2.y[1];
 505                         data[coff + 2] = cb3.y[0]; data[coff + 3] = cb3.y[1];
 506                         coff += ystride;
 507                         data[coff]     = cb2.y[2]; data[coff + 1] = cb2.y[3];
 508                         data[coff + 2] = cb3.y[2]; data[coff + 3] = cb3.y[3];
 509
 510                         if !self.grayscale {
 511                             let mut coff = uoff + x / 2;
 512                             data[coff] = cb0.u; data[coff + 1] = cb1.u;
 513                             coff += ustride;
 514                             data[coff] = cb2.u; data[coff + 1] = cb3.u;
 515
 516                             let mut coff = voff + x / 2;
 517                             data[coff] = cb0.v; data[coff + 1] = cb1.v;
 518                             coff += vstride;
 519                             data[coff] = cb2.v; data[coff + 1] = cb3.v;
 520                         }
 521                     }
 522                     cur_bit >>= 1;
 523                 }
 524                 yoff += ystride * 4;
 525                 uoff += ustride * 2;
 526                 voff += vstride * 2;
 527             }
 528         } else {
 529             unreachable!();
 530         }
 531     }
 532     fn calc_skip_dist(&mut self, in_frm: &NAVideoBuffer<u8>, start: usize, end: usize) {
 533         self.skip_dist.clear();
 534         if let Some(ref ref_frm) = self.lastfrm {
 535             let rystride  = ref_frm.get_stride(0);
 536             let mut ryoff = ref_frm.get_offset(0) + start * rystride;
 537             let rustride  = ref_frm.get_stride(1);
 538             let mut ruoff = ref_frm.get_offset(1) + start / 2 * rustride;
 539             let rvstride  = ref_frm.get_stride(2);
 540             let mut rvoff = ref_frm.get_offset(2) + start / 2 * rvstride;
 541             let (width, _) = ref_frm.get_dimensions(0);
 542             let rdata = ref_frm.get_data();
 543
 544             let iystride  = in_frm.get_stride(0);
 545             let mut iyoff = in_frm.get_offset(0) + start * iystride;
 546             let iustride  = in_frm.get_stride(1);
 547             let mut iuoff = in_frm.get_offset(1) + start / 2 * iustride;
 548             let ivstride  = in_frm.get_stride(2);
 549             let mut ivoff = in_frm.get_offset(2) + start / 2 * ivstride;
 550             let idata = in_frm.get_data();
 551
 552             for _ in (start..end).step_by(4) {
 553                 for x in (0..width).step_by(4) {
 554                     let mut dist = 0;
 555                     let mut roff = ryoff + x;
 556                     let mut ioff = iyoff + x;
 557                     for _ in 0..4 {
 558                         for i in 0..4 {
 559                             let d = i32::from(rdata[roff + i]) - i32::from(idata[ioff + i]);
 560                             dist += d * d;
 561                         }
 562                         roff += rystride;
 563                         ioff += iystride;
 564                     }
 565                     if !self.grayscale {
 566                         let mut roff = ruoff + x / 2;
 567                         let mut ioff = iuoff + x / 2;
 568                         let ud = i32::from(rdata[roff]) - i32::from(idata[ioff]);
 569                         dist += ud * ud;
 570                         let ud = i32::from(rdata[roff + 1]) - i32::from(idata[ioff + 1]);
 571                         dist += ud * ud;
 572                         roff += rustride; ioff += iustride;
 573                         let ud = i32::from(rdata[roff]) - i32::from(idata[ioff]);
 574                         dist += ud * ud;
 575                         let ud = i32::from(rdata[roff + 1]) - i32::from(idata[ioff + 1]);
 576                         dist += ud * ud;
 577
 578                         let mut roff = rvoff + x / 2;
 579                         let mut ioff = ivoff + x / 2;
 580                         let vd = i32::from(rdata[roff]) - i32::from(idata[ioff]);
 581                         dist += vd * vd;
 582                         let vd = i32::from(rdata[roff + 1]) - i32::from(idata[ioff + 1]);
 583                         dist += vd * vd;
 584                         roff += rvstride; ioff += ivstride;
 585                         let vd = i32::from(rdata[roff]) - i32::from(idata[ioff]);
 586                         dist += vd * vd;
 587                         let vd = i32::from(rdata[roff + 1]) - i32::from(idata[ioff + 1]);
 588                         dist += vd * vd;
 589                     }
 590                     self.skip_dist.push(dist as u32);
 591                 }
 592
 593                 iyoff += iystride * 4;
 594                 iuoff += iustride * 2;
 595                 ivoff += ivstride * 2;
 596                 ryoff += rystride * 4;
 597                 ruoff += rustride * 2;
 598                 rvoff += rvstride * 2;
 599             }
 600         } else {
 601             unreachable!();
 602         }
 603     }
 604     fn quant_vectors(&mut self) {
 605         match self.qmode {
 606             QuantMode::ELBG => {
 607                 let v1_len = quantise_median_cut::<YUVCode, YUVCodeSum>(&self.v1_entries, &mut self.v1_cur_cb[self.cur_strip]);
 608                 let v4_len = if !self.force_v1 {
 609                         quantise_median_cut::<YUVCode, YUVCodeSum>(&self.v4_entries, &mut self.v4_cur_cb[self.cur_strip])
 610                     } else {
 611                         0
 612                     };
 613                 self.v1_len = if v1_len < 256 {
 614                         v1_len
 615                     } else {
 616                         let mut elbg_v1: ELBG<YUVCode, YUVCodeSum> = ELBG::new(&self.v1_cur_cb[self.cur_strip]);
 617                         elbg_v1.quantise(&self.v1_entries, &mut self.v1_cur_cb[self.cur_strip])
 618                     };
 619                 self.v4_len = if v4_len < 256 {
 620                         v4_len
 621                     } else {
 622                         let mut elbg_v4: ELBG<YUVCode, YUVCodeSum> = ELBG::new(&self.v4_cur_cb[self.cur_strip]);
 623                         elbg_v4.quantise(&self.v4_entries, &mut self.v4_cur_cb[self.cur_strip])
 624                     };
 625             },
 626             QuantMode::MedianCut => {
 627                 self.v1_len = quantise_median_cut::<YUVCode, YUVCodeSum>(&self.v1_entries, &mut self.v1_cur_cb[self.cur_strip]);
 628                 if !self.force_v1 {
 629                     self.v4_len = quantise_median_cut::<YUVCode, YUVCodeSum>(&self.v4_entries, &mut self.v4_cur_cb[self.cur_strip]);
 630                 } else {
 631                     self.v4_len = 0;
 632                 }
 633             },
 634         };
 635
 636         for e in self.v1_cur_cb[self.cur_strip].iter_mut().skip(self.v1_len) { *e = YUVCode::default(); }
 637         for e in self.v4_cur_cb[self.cur_strip].iter_mut().skip(self.v4_len) { *e = YUVCode::default(); }
 638     }
 639     fn encode_intra(&mut self, bw: &mut ByteWriter, in_frm: &NAVideoBuffer<u8>) -> EncoderResult<bool> {
 640         let (width, height) = in_frm.get_dimensions(0);
 641         let mut strip_h = (height / self.nstrips + 3) & !3;
 642         if strip_h == 0 {
 643             self.nstrips = 1;
 644             strip_h = height;
 645         }
 646         let mut start_line = 0;
 647         let mut end_line = strip_h;
 648
 649         bw.write_byte(0)?; // intra flag
 650         bw.write_u24be(0)?; // frame size
 651         let frame_data_pos = bw.tell();
 652         bw.write_u16be(width as u16)?;
 653         bw.write_u16be(height as u16)?;
 654         bw.write_u16be(self.nstrips as u16)?;
 655
 656         self.cur_strip = 0;
 657         for entry in self.v1_cb[self.cur_strip].iter_mut() {
 658             self.rng.fill_entry(entry);
 659         }
 660         for entry in self.v4_cb[self.cur_strip].iter_mut() {
 661             self.rng.fill_entry(entry);
 662         }
 663         while start_line < height {
 664             self.read_strip(in_frm, start_line, end_line);
 665
 666             if self.cur_strip > 0 {
 667                 self.v1_cb[self.cur_strip] = self.v1_cb[self.cur_strip - 1];
 668                 self.v4_cb[self.cur_strip] = self.v4_cb[self.cur_strip - 1];
 669             }
 670             self.quant_vectors();
 671             if self.grayscale {
 672                 for cw in self.v1_cur_cb[self.cur_strip].iter_mut() {
 673                     cw.u = 128;
 674                     cw.v = 128;
 675                 }
 676                 for cw in self.v4_cur_cb[self.cur_strip].iter_mut() {
 677                     cw.u = 128;
 678                     cw.v = 128;
 679                 }
 680             }
 681
 682             self.v1_idx.clear();
 683             self.v4_idx.clear();
 684             self.masks.reset();
 685
 686             for (v1_entry, v4_entries) in self.v1_entries.iter().zip(self.v4_entries.chunks(4)) {
 687                 let (v1_idx, v1_dist) = Self::find_nearest(&self.v1_cur_cb[self.cur_strip][..self.v1_len], *v1_entry);
 688                 if v1_dist == 0 || self.force_v1 {
 689                     self.masks.put_v1();
 690                     self.v1_idx.push(v1_idx);
 691                     continue;
 692                 }
 693                 let (v40_idx, v40_dist) = Self::find_nearest(&self.v4_cur_cb[self.cur_strip][..self.v4_len], v4_entries[0]);
 694                 let (v41_idx, v41_dist) = Self::find_nearest(&self.v4_cur_cb[self.cur_strip][..self.v4_len], v4_entries[1]);
 695                 let (v42_idx, v42_dist) = Self::find_nearest(&self.v4_cur_cb[self.cur_strip][..self.v4_len], v4_entries[2]);
 696                 let (v43_idx, v43_dist) = Self::find_nearest(&self.v4_cur_cb[self.cur_strip][..self.v4_len], v4_entries[3]);
 697                 if v40_dist + v41_dist + v42_dist + v43_dist > v1_dist {
 698                     self.masks.put_v4();
 699                     self.v4_idx.push(v40_idx);
 700                     self.v4_idx.push(v41_idx);
 701                     self.v4_idx.push(v42_idx);
 702                     self.v4_idx.push(v43_idx);
 703                 } else {
 704                     self.masks.put_v1();
 705                     self.v1_idx.push(v1_idx);
 706                 }
 707             }
 708             self.masks.end();
 709
 710             let mut is_intra_strip = start_line == 0;
 711             let (upd_v1, upd_v4) = if !is_intra_strip {
 712                     let cb_size = if self.grayscale { 4 } else { 6 };
 713                     (Self::can_update_cb(&self.v1_cur_cb[self.cur_strip][..self.v1_len], &self.v1_cb[self.cur_strip][..self.v1_len], cb_size),
 714                      Self::can_update_cb(&self.v4_cur_cb[self.cur_strip][..self.v4_len], &self.v4_cb[self.cur_strip][..self.v4_len], cb_size))
 715                 } else {
 716                     (false, false)
 717                 };
 718             if !is_intra_strip && !upd_v1 && !upd_v4 {
 719                 is_intra_strip = true;
 720             }
 721             bw.write_byte(if is_intra_strip { 0x10 } else { 0x11 })?;
 722             bw.write_u24be(0)?; // strip size
 723             let strip_data_pos = bw.tell();
 724             bw.write_u16be(0)?; // yoff
 725             bw.write_u16be(0)?; // xoff
 726             bw.write_u16be((end_line - start_line) as u16)?;
 727             bw.write_u16be(width as u16)?;
 728
 729             Self::write_cb(bw, 0x20, &self.v4_cur_cb[self.cur_strip], &self.v4_cb[self.cur_strip], self.grayscale, upd_v4, self.v4_len)?;
 730             Self::write_cb(bw, 0x22, &self.v1_cur_cb[self.cur_strip], &self.v1_cb[self.cur_strip], self.grayscale, upd_v1, self.v1_len)?;
 731
 732             self.render_stripe(true, start_line, end_line);
 733
 734             if self.v4_idx.is_empty() {
 735                 bw.write_byte(0x32)?;
 736                 bw.write_u24be((self.v1_idx.len() + 4) as u32)?;
 737                 bw.write_buf(self.v1_idx.as_slice())?;
 738             } else {
 739                 bw.write_byte(0x30)?;
 740                 bw.write_u24be(0)?;
 741                 let chunk_pos = bw.tell();
 742                 let mut v1_pos = 0;
 743                 let mut v4_pos = 0;
 744                 for _ in 0..32 {
 745                     self.v1_idx.push(0);
 746                     self.v4_idx.push(0);
 747                     self.v4_idx.push(0);
 748                     self.v4_idx.push(0);
 749                     self.v4_idx.push(0);
 750                 }
 751                 for mask in self.masks.masks.iter() {
 752                     bw.write_u32be(*mask)?;
 753                     for j in (0..32).rev() {
 754                         if (mask & (1 << j)) == 0 {
 755                             bw.write_byte(self.v1_idx[v1_pos])?;
 756                             v1_pos += 1;
 757                         } else {
 758                             bw.write_byte(self.v4_idx[v4_pos])?;
 759                             bw.write_byte(self.v4_idx[v4_pos + 1])?;
 760                             bw.write_byte(self.v4_idx[v4_pos + 2])?;
 761                             bw.write_byte(self.v4_idx[v4_pos + 3])?;
 762                             v4_pos += 4;
 763                         }
 764                     }
 765                 }
 766                 patch_size(bw, chunk_pos)?;
 767             }
 768
 769             patch_size(bw, strip_data_pos)?;
 770
 771             self.v1_cb[self.cur_strip].copy_from_slice(&self.v1_cur_cb[self.cur_strip]);
 772             self.v4_cb[self.cur_strip].copy_from_slice(&self.v4_cur_cb[self.cur_strip]);
 773             start_line = end_line;
 774             end_line = (end_line + strip_h).min(height);
 775
 776             self.cur_strip += 1;
 777         }
 778         patch_size(bw, frame_data_pos)?;
 779         Ok(true)
 780     }
 781     fn encode_inter(&mut self, bw: &mut ByteWriter, in_frm: &NAVideoBuffer<u8>) -> EncoderResult<bool> {
 782         let (width, height) = in_frm.get_dimensions(0);
 783         let mut strip_h = (height / self.nstrips + 3) & !3;
 784         if strip_h == 0 {
 785             self.nstrips = 1;
 786             strip_h = height;
 787         }
 788         let mut start_line = 0;
 789         let mut end_line = strip_h;
 790
 791         bw.write_byte(1)?; // intra flag
 792         bw.write_u24be(0)?; // frame size
 793         let frame_data_pos = bw.tell();
 794         bw.write_u16be(width as u16)?;
 795         bw.write_u16be(height as u16)?;
 796         bw.write_u16be(self.nstrips as u16)?;
 797
 798         self.cur_strip = 0;
 799         while start_line < height {
 800             self.read_strip(in_frm, start_line, end_line);
 801             self.calc_skip_dist(in_frm, start_line, end_line);
 802
 803             self.quant_vectors();
 804             if self.grayscale {
 805                 for cw in self.v1_cur_cb[self.cur_strip].iter_mut() {
 806                     cw.u = 128;
 807                     cw.v = 128;
 808                 }
 809                 for cw in self.v4_cur_cb[self.cur_strip].iter_mut() {
 810                     cw.u = 128;
 811                     cw.v = 128;
 812                 }
 813             }
 814
 815             self.v1_idx.clear();
 816             self.v4_idx.clear();
 817             self.masks.reset();
 818
 819             let mut skip_iter = self.skip_dist.iter();
 820             for (v1_entry, v4_entries) in self.v1_entries.iter().zip(self.v4_entries.chunks(4)) {
 821                 let skip_dist = *skip_iter.next().unwrap();
 822                 if skip_dist == 0 {
 823                     self.masks.put_inter(true);
 824                     continue;
 825                 }
 826                 let (v1_idx, v1_dist) = Self::find_nearest(&self.v1_cur_cb[self.cur_strip][..self.v1_len], *v1_entry);
 827                 if skip_dist < v1_dist {
 828                     self.masks.put_inter(true);
 829                     continue;
 830                 } else {
 831                     self.masks.put_inter(false);
 832                 }
 833                 if v1_dist == 0 || self.force_v1 {
 834                     self.masks.put_v1();
 835                     self.v1_idx.push(v1_idx);
 836                     continue;
 837                 }
 838                 let (v40_idx, v40_dist) = Self::find_nearest(&self.v4_cur_cb[self.cur_strip][..self.v4_len], v4_entries[0]);
 839                 let (v41_idx, v41_dist) = Self::find_nearest(&self.v4_cur_cb[self.cur_strip][..self.v4_len], v4_entries[1]);
 840                 let (v42_idx, v42_dist) = Self::find_nearest(&self.v4_cur_cb[self.cur_strip][..self.v4_len], v4_entries[2]);
 841                 let (v43_idx, v43_dist) = Self::find_nearest(&self.v4_cur_cb[self.cur_strip][..self.v4_len], v4_entries[3]);
 842                 if v40_dist + v41_dist + v42_dist + v43_dist > v1_dist {
 843                     self.masks.put_v4();
 844                     self.v4_idx.push(v40_idx);
 845                     self.v4_idx.push(v41_idx);
 846                     self.v4_idx.push(v42_idx);
 847                     self.v4_idx.push(v43_idx);
 848                 } else {
 849                     self.masks.put_v1();
 850                     self.v1_idx.push(v1_idx);
 851                 }
 852             }
 853             self.masks.end();
 854
 855             let (upd_v1, upd_v4) = {
 856                     let cb_size = if self.grayscale { 4 } else { 6 };
 857                     (Self::can_update_cb(&self.v1_cur_cb[self.cur_strip][..self.v1_len], &self.v1_cb[self.cur_strip][..self.v1_len], cb_size),
 858                      Self::can_update_cb(&self.v4_cur_cb[self.cur_strip][..self.v4_len], &self.v4_cb[self.cur_strip][..self.v4_len], cb_size))
 859                 };
 860             bw.write_byte(0x11)?;
 861             bw.write_u24be(0)?; // strip size
 862             let strip_data_pos = bw.tell();
 863             bw.write_u16be(0)?; // yoff
 864             bw.write_u16be(0)?; // xoff
 865             bw.write_u16be((end_line - start_line) as u16)?;
 866             bw.write_u16be(width as u16)?;
 867
 868             Self::write_cb(bw, 0x20, &self.v4_cur_cb[self.cur_strip], &self.v4_cb[self.cur_strip], self.grayscale, upd_v4, self.v4_len)?;
 869             Self::write_cb(bw, 0x22, &self.v1_cur_cb[self.cur_strip], &self.v1_cb[self.cur_strip], self.grayscale, upd_v1, self.v1_len)?;
 870
 871             self.render_stripe(false, start_line, end_line);
 872
 873             bw.write_byte(0x31)?;
 874             bw.write_u24be(0)?;
 875             let chunk_pos = bw.tell();
 876             let mut v1_pos = 0;
 877             let mut v4_pos = 0;
 878             for _ in 0..32 {
 879                 self.v1_idx.push(0);
 880                 self.v4_idx.push(0);
 881                 self.v4_idx.push(0);
 882                 self.v4_idx.push(0);
 883                 self.v4_idx.push(0);
 884             }
 885             let mut skip = true;
 886             for mask in self.masks.masks.iter() {
 887                 bw.write_u32be(*mask)?;
 888                 if *mask == 0 && skip { continue; }
 889                 let mut bit = 1 << 31;
 890                 while bit > 0 {
 891                     if skip {
 892                         skip = (mask & bit) == 0;
 893                         bit >>= 1;
 894                     } else {
 895                         if (mask & bit) == 0 {
 896                             bw.write_byte(self.v1_idx[v1_pos])?;
 897                             v1_pos += 1;
 898                         } else {
 899                             bw.write_byte(self.v4_idx[v4_pos])?;
 900                             bw.write_byte(self.v4_idx[v4_pos + 1])?;
 901                             bw.write_byte(self.v4_idx[v4_pos + 2])?;
 902                             bw.write_byte(self.v4_idx[v4_pos + 3])?;
 903                             v4_pos += 4;
 904                         }
 905                         bit >>= 1;
 906                         skip = true;
 907                     }
 908                 }
 909             }
 910             patch_size(bw, chunk_pos)?;
 911
 912             patch_size(bw, strip_data_pos)?;
 913
 914             self.v1_cb[self.cur_strip].copy_from_slice(&self.v1_cur_cb[self.cur_strip]);
 915             self.v4_cb[self.cur_strip].copy_from_slice(&self.v4_cur_cb[self.cur_strip]);
 916             start_line = end_line;
 917             end_line = (end_line + strip_h).min(height);
 918
 919             self.cur_strip += 1;
 920         }
 921         patch_size(bw, frame_data_pos)?;
 922         Ok(true)
 923     }
 924 }
 925
 926 impl NAEncoder for CinepakEncoder {
 927     fn negotiate_format(&self, encinfo: &EncodeParameters) -> EncoderResult<EncodeParameters> {
 928         match encinfo.format {
 929             NACodecTypeInfo::None => {
 930                 Ok(EncodeParameters {
 931                         format: NACodecTypeInfo::Video(NAVideoInfo::new(0, 0, true, YUV420_FORMAT)),
 932                         ..Default::default()
 933                     })
 934             },
 935             NACodecTypeInfo::Audio(_) => Err(EncoderError::FormatError),
 936             NACodecTypeInfo::Video(vinfo) => {
 937                 let pix_fmt = if vinfo.format == GRAY_FORMAT { GRAY_FORMAT } else { YUV420_FORMAT };
 938                 let outinfo = NAVideoInfo::new((vinfo.width + 3) & !3, (vinfo.height + 3) & !3, false, pix_fmt);
 939                 let mut ofmt = *encinfo;
 940                 ofmt.format = NACodecTypeInfo::Video(outinfo);
 941                 Ok(ofmt)
 942             }
 943         }
 944     }
 945     fn get_capabilities(&self) -> u64 { 0 }
 946     fn init(&mut self, stream_id: u32, encinfo: EncodeParameters) -> EncoderResult<NAStreamRef> {
 947         match encinfo.format {
 948             NACodecTypeInfo::None => Err(EncoderError::FormatError),
 949             NACodecTypeInfo::Audio(_) => Err(EncoderError::FormatError),
 950             NACodecTypeInfo::Video(vinfo) => {
 951                 if vinfo.format != YUV420_FORMAT && vinfo.format != GRAY_FORMAT {
 952                     return Err(EncoderError::FormatError);
 953                 }
 954                 if ((vinfo.width | vinfo.height) & 3) != 0 {
 955                     return Err(EncoderError::FormatError);
 956                 }
 957                 if (vinfo.width | vinfo.height) >= (1 << 16) {
 958                     return Err(EncoderError::FormatError);
 959                 }
 960
 961                 let out_info = NAVideoInfo::new(vinfo.width, vinfo.height, false, vinfo.format);
 962                 let info = NACodecInfo::new("cinepak", NACodecTypeInfo::Video(out_info), None);
 963                 let mut stream = NAStream::new(StreamType::Video, stream_id, info, encinfo.tb_num, encinfo.tb_den, 0);
 964                 stream.set_num(stream_id as usize);
 965                 let stream = stream.into_ref();
 966
 967                 self.stream = Some(stream.clone());
 968                 self.quality = encinfo.quality;
 969                 self.grayscale = vinfo.format != YUV420_FORMAT;
 970                 let num_blocks = vinfo.width / 2 * vinfo.height / 2;
 971                 self.v1_entries = Vec::with_capacity(num_blocks);
 972                 self.v4_entries = Vec::with_capacity(num_blocks * 4);
 973                 self.v1_idx = Vec::with_capacity(num_blocks);
 974                 self.v4_idx = Vec::with_capacity(num_blocks * 4);
 975                 self.skip_dist = Vec::with_capacity(vinfo.width / 4 * vinfo.height / 4);
 976
 977                 let buf = alloc_video_buffer(out_info, 2)?;
 978                 self.lastfrm = Some(buf.get_vbuf().unwrap());
 979
 980                 Ok(stream)
 981             },
 982         }
 983     }
 984     fn encode(&mut self, frm: &NAFrame) -> EncoderResult<()> {
 985         let buf = frm.get_buffer();
 986         if let Some(ref vbuf) = buf.get_vbuf() {
 987             if self.nstrips == 0 {
 988                 let (w, h) = vbuf.get_dimensions(0);
 989                 self.nstrips = ((((w * h) >> 4) + 1200) / 2400).max(1).min(3);
 990                 let strip_h = ((h + self.nstrips - 1) / self.nstrips + 3) & !3;
 991                 self.nstrips = (h + strip_h - 1) / strip_h;
 992             }
 993             let cur_strips = self.v1_cb.len();
 994             if cur_strips != self.nstrips {
 995                 self.frmcount = 0;
 996             }
 997             if cur_strips < self.nstrips {
 998                 for _ in cur_strips..self.nstrips {
 999                     self.v1_cb.push([YUVCode::default(); 256]);
1000                     self.v4_cb.push([YUVCode::default(); 256]);
1001                     self.v1_cur_cb.push([YUVCode::default(); 256]);
1002                     self.v4_cur_cb.push([YUVCode::default(); 256]);
1003                 }
1004             }
1005
1006             let mut dbuf = Vec::with_capacity(4);
1007             let mut gw   = GrowableMemoryWriter::new_write(&mut dbuf);
1008             let mut bw   = ByteWriter::new(&mut gw);
1009             let is_intra = if self.frmcount == 0 {
1010                     self.encode_intra(&mut bw, vbuf)?
1011                 } else {
1012                     self.encode_inter(&mut bw, vbuf)?
1013                 };
1014             self.pkt = Some(NAPacket::new(self.stream.clone().unwrap(), frm.ts, is_intra, dbuf));
1015             self.frmcount += 1;
1016             if self.frmcount == self.key_int {
1017                 self.frmcount = 0;
1018             }
1019             Ok(())
1020         } else {
1021             Err(EncoderError::InvalidParameters)
1022         }
1023     }
1024     fn get_packet(&mut self) -> EncoderResult<Option<NAPacket>> {
1025         let mut npkt = None;
1026         std::mem::swap(&mut self.pkt, &mut npkt);
1027         Ok(npkt)
1028     }
1029     fn flush(&mut self) -> EncoderResult<()> {
1030         self.frmcount = 0;
1031         Ok(())
1032     }
1033 }
1034
1035 const ENCODER_OPTS: &[NAOptionDefinition] = &[
1036     NAOptionDefinition {
1037         name: KEYFRAME_OPTION, description: KEYFRAME_OPTION_DESC,
1038         opt_type: NAOptionDefinitionType::Int(Some(0), Some(128)) },
1039     NAOptionDefinition {
1040         name: "nstrips", description: "Number of strips per frame (0 - automatic)",
1041         opt_type: NAOptionDefinitionType::Int(Some(0), Some(16)) },
1042     NAOptionDefinition {
1043         name: "quant_mode", description: "Quantisation mode",
1044         opt_type: NAOptionDefinitionType::String(Some(&["elbg", "mediancut"])) },
1045     NAOptionDefinition {
1046         name: "force_v1", description: "Force coarse (V1-only) mode",
1047         opt_type: NAOptionDefinitionType::Bool },
1048 ];
1049
1050 impl NAOptionHandler for CinepakEncoder {
1051     fn get_supported_options(&self) -> &[NAOptionDefinition] { ENCODER_OPTS }
1052     fn set_options(&mut self, options: &[NAOption]) {
1053         for option in options.iter() {
1054             for opt_def in ENCODER_OPTS.iter() {
1055                 if opt_def.check(option).is_ok() {
1056                     match option.name {
1057                         KEYFRAME_OPTION => {
1058                             if let NAValue::Int(intval) = option.value {
1059                                 self.key_int = intval as u8;
1060                             }
1061                         },
1062                         "nstrips" => {
1063                             if let NAValue::Int(intval) = option.value {
1064                                 self.nstrips = intval as usize;
1065                             }
1066                         },
1067                         "quant_mode" => {
1068                             if let NAValue::String(ref strval) = option.value {
1069                                 match strval.as_str() {
1070                                     "elbg"      => self.qmode = QuantMode::ELBG,
1071                                     "mediancut" => self.qmode = QuantMode::MedianCut,
1072                                     _ => {},
1073                                 };
1074                             }
1075                         },
1076                         "force_v1" => {
1077                             if let NAValue::Bool(val) = option.value {
1078                                 self.force_v1 = val;
1079                             }
1080                         },
1081                         _ => {},
1082                     };
1083                 }
1084             }
1085         }
1086     }
1087     fn query_option_value(&self, name: &str) -> Option<NAValue> {
1088         match name {
1089             KEYFRAME_OPTION => Some(NAValue::Int(i64::from(self.key_int))),
1090             "nstrips" => Some(NAValue::Int(self.nstrips as i64)),
1091             "quant_mode" => Some(NAValue::String(self.qmode.to_string())),
1092             "force_v1" => Some(NAValue::Bool(self.force_v1)),
1093             _ => None,
1094         }
1095     }
1096 }
1097
1098 pub fn get_encoder() -> Box<dyn NAEncoder + Send> {
1099     Box::new(CinepakEncoder::new())
1100 }
1101
1102 #[cfg(test)]
1103 mod test {
1104     use nihav_core::codecs::*;
1105     use nihav_core::demuxers::*;
1106     use nihav_core::muxers::*;
1107     use crate::*;
1108     use nihav_codec_support::test::enc_video::*;
1109
1110     #[test]
1111     fn test_cinepak_encoder() {
1112         let mut dmx_reg = RegisteredDemuxers::new();
1113         generic_register_all_demuxers(&mut dmx_reg);
1114         let mut dec_reg = RegisteredDecoders::new();
1115         generic_register_all_decoders(&mut dec_reg);
1116         let mut mux_reg = RegisteredMuxers::new();
1117         generic_register_all_muxers(&mut mux_reg);
1118         let mut enc_reg = RegisteredEncoders::new();
1119         generic_register_all_encoders(&mut enc_reg);
1120
1121         // sample: https://samples.mplayerhq.hu/V-codecs/UCOD/TalkingHead_352x288.avi
1122         let dec_config = DecoderTestParams {
1123                 demuxer:        "avi",
1124                 in_name:        "assets/Misc/TalkingHead_352x288.avi",
1125                 stream_type:    StreamType::Video,
1126                 limit:          Some(2),
1127                 dmx_reg, dec_reg,
1128             };
1129         let enc_config = EncoderTestParams {
1130                 muxer:          "avi",
1131                 enc_name:       "cinepak",
1132                 out_name:       "cinepak.avi",
1133                 mux_reg, enc_reg,
1134             };
1135         let dst_vinfo = NAVideoInfo {
1136                 width:   0,
1137                 height:  0,
1138                 format:  YUV420_FORMAT,
1139                 flipped: true,
1140                 bits:    12,
1141             };
1142         let enc_params = EncodeParameters {
1143                 format:  NACodecTypeInfo::Video(dst_vinfo),
1144                 quality: 0,
1145                 bitrate: 0,
1146                 tb_num:  0,
1147                 tb_den:  0,
1148                 flags:   0,
1149             };
1150         //test_encoding_to_file(&dec_config, &enc_config, enc_params, &[]);
1151         test_encoding_md5(&dec_config, &enc_config, enc_params, &[],
1152                           &[0x1d4690c8, 0x3b15b4b3, 0xc2df3c7b, 0x1a25b159]);
1153     }
1154 }