1 use nihav_core::codecs::*;
2 use nihav_core::io::byteio::*;
3 use nihav_codec_support::vq::*;
5 #[derive(Default,Clone,Copy,PartialEq,Debug)]
11 impl VQElement for YUVCode {
12 fn dist(&self, rval: Self) -> u32 {
14 for (y0, y1) in self.y.iter().zip(rval.y.iter()) {
15 let yd = i32::from(*y0) - i32::from(*y1);
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
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();
27 ycode.y[i] = self.y[i].min(rval.y[i]);
29 ycode.u = self.u.min(rval.u);
30 ycode.v = self.v.min(rval.v);
33 fn max(&self, rval: Self) -> Self {
34 let mut ycode = YUVCode::default();
36 ycode.y[i] = self.y[i].max(rval.y[i]);
38 ycode.u = self.u.max(rval.u);
39 ycode.v = self.v.max(rval.v);
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],
53 let mut offs = [0; 256];
55 offs[i + 1] = offs[i] + counts[i];
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],
64 dst[offs[idx]] = *entry;
67 arr.copy_from_slice(dst.as_slice());
69 fn max_dist_component(min: &Self, max: &Self) -> usize {
73 let d = u32::from(max.y[i]) - u32::from(min.y[i]);
79 let ud = u32::from(max.u) - u32::from(min.u);
84 let vd = u32::from(max.v) - u32::from(min.v);
100 impl VQElementSum<YUVCode> for YUVCodeSum {
101 fn zero() -> Self { Self::default() }
102 fn add(&mut self, rval: YUVCode, count: u64) {
104 self.ysum[i] += u64::from(rval.y[i]) * count;
106 self.usum += u64::from(rval.u) * count;
107 self.vsum += u64::from(rval.v) * count;
110 fn get_centroid(&self) -> YUVCode {
112 let mut ycode = YUVCode::default();
114 ycode.y[i] = ((self.ysum[i] + self.count / 2) / self.count) as u8;
116 ycode.u = ((self.usum + self.count / 2) / self.count) as u8;
117 ycode.v = ((self.vsum + self.count / 2) / self.count) as u8;
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);
136 (self.seed >> 24) as u8
138 fn fill_entry(&mut self, entry: &mut YUVCode) {
139 for y in entry.y.iter_mut() {
142 entry.u = self.next();
143 entry.v = self.next();
147 const GRAY_FORMAT: NAPixelFormaton = NAPixelFormaton {
148 model: ColorModel::YUV(YUVSubmodel::YUVJ),
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],
171 fn reset(&mut self) {
176 fn put_v1(&mut self) {
183 fn put_v4(&mut self) {
191 fn put_inter(&mut self, skip: bool) {
193 self.mask |= !skip as u32;
199 fn flush(&mut self) {
200 self.masks.push(self.mask);
205 if self.pos == 0 { return; }
206 while self.pos < 32 {
214 #[derive(Clone,Copy,PartialEq)]
221 impl std::string::ToString for QuantMode {
222 fn to_string(&self) -> String {
224 QuantMode::ELBG => "elbg".to_string(),
225 QuantMode::Fast => "fast".to_string(),
226 QuantMode::MedianCut => "mediancut".to_string(),
231 struct CinepakEncoder {
232 stream: Option<NAStreamRef>,
233 lastfrm: Option<NAVideoBufferRef<u8>>,
234 pkt: Option<NAPacket>,
242 v1_entries: Vec<YUVCode>,
243 v4_entries: Vec<YUVCode>,
244 v1_cb: Vec<[YUVCode; 256]>,
245 v4_cb: Vec<[YUVCode; 256]>,
246 v1_cur_cb: Vec<[YUVCode; 256]>,
247 v4_cur_cb: Vec<[YUVCode; 256]>,
256 fst_bins: [Vec<YUVCode>; 4],
259 fn avg4(a: u8, b: u8, c: u8, d: u8) -> u8 {
260 ((u16::from(a) + u16::from(b) + u16::from(c) + u16::from(d) + 3) >> 2) as u8
263 fn variance(a: u8, mean: u8) -> u32 {
265 u32::from(a - mean) * u32::from(a - mean)
267 u32::from(mean - a) * u32::from(mean - a)
271 fn patch_size(bw: &mut ByteWriter, pos: u64) -> EncoderResult<()> {
272 let size = bw.tell() - pos;
273 bw.seek(SeekFrom::Current(-((size + 3) as i64)))?;
274 bw.write_u24be((size + 4) as u32)?;
275 bw.seek(SeekFrom::End(0))?;
279 fn elbg_quant(entries: &[YUVCode], codebook: &mut [YUVCode]) -> usize {
280 let cb_len = quantise_median_cut::<YUVCode, YUVCodeSum>(entries, codebook);
281 if cb_len < codebook.len() {
284 let mut elbg: ELBG<YUVCode, YUVCodeSum> = ELBG::new(codebook);
285 elbg.quantise(entries, codebook)
289 fn quant_fast(bins: &mut [Vec<YUVCode>; 4], entries: &[YUVCode], codebook: &mut [YUVCode]) -> usize {
290 for bin in bins.iter_mut() {
293 for &entry in entries.iter() {
294 let y_avg = avg4(entry.y[0], entry.y[1], entry.y[2], entry.y[3]);
295 let dist = entry.y.iter().fold(0u32, |acc, &x| acc + variance(x, y_avg));
296 let ilog = if dist == 0 { 0 } else { 32 - dist.leading_zeros() };
297 let bin = match ilog {
298 0..=3 => &mut bins[0],
299 4..=7 => &mut bins[1],
300 8..=11 => &mut bins[2],
305 let mut free_cw = codebook.len();
306 let mut entries_left = entries.len();
308 for bin in bins.iter() {
312 if free_cw == 0 || entries_left == 0 {
315 let target = (free_cw * bin.len() + entries_left - 1) / entries_left;
316 let cur_len = elbg_quant(bin, &mut codebook[offset..][..target]);
319 entries_left -= bin.len();
324 impl CinepakEncoder {
331 qmode: QuantMode::Fast,
337 v1_entries: Vec::new(),
338 v4_entries: Vec::new(),
339 v1_cb: Vec::with_capacity(2),
340 v4_cb: Vec::with_capacity(2),
341 v1_cur_cb: Vec::with_capacity(2),
342 v4_cur_cb: Vec::with_capacity(2),
349 masks: MaskWriter::new(),
350 skip_dist: Vec::new(),
351 fst_bins: [Vec::new(), Vec::new(), Vec::new(), Vec::new()],
354 fn read_strip(&mut self, in_frm: &NAVideoBuffer<u8>, start: usize, end: usize) {
355 let ystride = in_frm.get_stride(0);
356 let mut yoff = in_frm.get_offset(0) + start * ystride;
357 let ustride = in_frm.get_stride(1);
358 let mut uoff = in_frm.get_offset(1) + start / 2 * ustride;
359 let vstride = in_frm.get_stride(2);
360 let mut voff = in_frm.get_offset(2) + start / 2 * vstride;
361 let (width, _) = in_frm.get_dimensions(0);
362 let data = in_frm.get_data();
363 self.v1_entries.clear();
364 self.v4_entries.clear();
365 for _ in (start..end).step_by(4) {
366 for x in (0..width).step_by(4) {
367 let mut yblk = [0; 16];
368 let mut ublk = [128; 4];
369 let mut vblk = [128; 4];
372 yblk[i + j * 4] = data[yoff + x + i + j * ystride];
378 ublk[i + j * 2] = data[uoff + x / 2 + i + j * ustride];
379 vblk[i + j * 2] = data[voff + x / 2 + i + j * vstride];
383 self.v1_entries.push(YUVCode {
384 y: [avg4(yblk[ 0], yblk[ 1], yblk[ 4], yblk[ 5]),
385 avg4(yblk[ 2], yblk[ 3], yblk[ 6], yblk[ 7]),
386 avg4(yblk[ 8], yblk[ 9], yblk[12], yblk[13]),
387 avg4(yblk[10], yblk[11], yblk[14], yblk[15])],
388 u: avg4(ublk[0], ublk[1], ublk[2], ublk[3]),
389 v: avg4(vblk[0], vblk[1], vblk[2], vblk[3]),
392 let yidx = (i & 1) * 2 + (i & 2) * 4;
393 self.v4_entries.push(YUVCode {
394 y: [ yblk[yidx], yblk[yidx + 1], yblk[yidx + 4], yblk[yidx + 5] ],
405 fn find_nearest(codebook: &[YUVCode], code: YUVCode) -> (u8, u32) {
406 let mut min_dist = std::u32::MAX;
408 for (i, cw) in codebook.iter().enumerate() {
409 let dist = cw.dist(code);
418 (idx as u8, min_dist)
420 fn can_update_cb(new_cb: &[YUVCode], old_cb: &[YUVCode], cb_size: usize) -> bool {
421 let mut skip_count = 0;
422 for (new, old) in new_cb.iter().zip(old_cb.iter()) {
427 let full_size = cb_size * new_cb.len();
428 let upd_size = cb_size * (new_cb.len() - skip_count) + (new_cb.len() + 31) / 32 * 4;
431 fn write_cb(bw: &mut ByteWriter, mut id: u8, new_cb: &[YUVCode], old_cb: &[YUVCode], grayscale: bool, update: bool, num_elem: usize) -> EncoderResult<()> {
440 let chunk_pos = bw.tell();
442 for entry in new_cb.iter().take(num_elem) {
443 bw.write_buf(&entry.y)?;
445 bw.write_byte(entry.u ^ 0x80)?;
446 bw.write_byte(entry.v ^ 0x80)?;
450 let mut end = num_elem;
451 for (i, (ncw, ocw)) in new_cb.iter().zip(old_cb.iter()).enumerate().take(num_elem).rev() {
458 for i in (0..end).step_by(32) {
462 if new_cb[i + j] != old_cb[i + j] {
466 bw.write_u32be(mask)?;
468 if new_cb[i + j] == old_cb[i + j] { continue; }
469 bw.write_buf(&new_cb[i + j].y)?;
471 bw.write_byte(new_cb[i + j].u ^ 0x80)?;
472 bw.write_byte(new_cb[i + j].v ^ 0x80)?;
477 patch_size(bw, chunk_pos)?;
480 fn render_stripe(&mut self, intra: bool, start: usize, end: usize) {
481 if let Some(ref mut dst_frm) = self.lastfrm {
482 let ystride = dst_frm.get_stride(0);
483 let mut yoff = dst_frm.get_offset(0) + start * ystride;
484 let ustride = dst_frm.get_stride(1);
485 let mut uoff = dst_frm.get_offset(1) + start / 2 * ustride;
486 let vstride = dst_frm.get_stride(2);
487 let mut voff = dst_frm.get_offset(2) + start / 2 * vstride;
488 let (width, _) = dst_frm.get_dimensions(0);
489 let data = dst_frm.get_data_mut().unwrap();
490 let mut miter = self.masks.masks.iter();
491 let mut v1_iter = self.v1_idx.iter();
492 let mut v4_iter = self.v4_idx.iter();
493 let mut cur_mask = 0;
495 for _ in (start..end).step_by(4) {
496 for x in (0..width).step_by(4) {
498 if !intra || !self.v1_idx.is_empty() {
499 cur_mask = *miter.next().unwrap();
501 cur_mask = 0xFFFFFFFF;
506 if (cur_mask & cur_bit) == 0 {
512 cur_mask = *miter.next().unwrap();
516 if (cur_mask & cur_bit) == 0 {
517 let idx = *v1_iter.next().unwrap() as usize;
518 let cb = &self.v1_cur_cb[self.cur_strip][idx];
520 let mut coff = yoff + x;
521 data[coff] = cb.y[0]; data[coff + 1] = cb.y[0];
522 data[coff + 2] = cb.y[1]; data[coff + 3] = cb.y[1];
524 data[coff] = cb.y[0]; data[coff + 1] = cb.y[0];
525 data[coff + 2] = cb.y[1]; data[coff + 3] = cb.y[1];
527 data[coff] = cb.y[2]; data[coff + 1] = cb.y[2];
528 data[coff + 2] = cb.y[3]; data[coff + 3] = cb.y[3];
530 data[coff] = cb.y[2]; data[coff + 1] = cb.y[2];
531 data[coff + 2] = cb.y[3]; data[coff + 3] = cb.y[3];
534 let mut coff = uoff + x / 2;
535 data[coff] = cb.u; data[coff + 1] = cb.u;
537 data[coff] = cb.u; data[coff + 1] = cb.u;
539 let mut coff = voff + x / 2;
540 data[coff] = cb.v; data[coff + 1] = cb.v;
542 data[coff] = cb.v; data[coff + 1] = cb.v;
545 let idx0 = *v4_iter.next().unwrap() as usize;
546 let cb0 = &self.v4_cur_cb[self.cur_strip][idx0];
547 let idx1 = *v4_iter.next().unwrap() as usize;
548 let cb1 = &self.v4_cur_cb[self.cur_strip][idx1];
549 let idx2 = *v4_iter.next().unwrap() as usize;
550 let cb2 = &self.v4_cur_cb[self.cur_strip][idx2];
551 let idx3 = *v4_iter.next().unwrap() as usize;
552 let cb3 = &self.v4_cur_cb[self.cur_strip][idx3];
554 let mut coff = yoff + x;
555 data[coff] = cb0.y[0]; data[coff + 1] = cb0.y[1];
556 data[coff + 2] = cb1.y[0]; data[coff + 3] = cb1.y[1];
558 data[coff] = cb0.y[2]; data[coff + 1] = cb0.y[3];
559 data[coff + 2] = cb1.y[2]; data[coff + 3] = cb1.y[3];
561 data[coff] = cb2.y[0]; data[coff + 1] = cb2.y[1];
562 data[coff + 2] = cb3.y[0]; data[coff + 3] = cb3.y[1];
564 data[coff] = cb2.y[2]; data[coff + 1] = cb2.y[3];
565 data[coff + 2] = cb3.y[2]; data[coff + 3] = cb3.y[3];
568 let mut coff = uoff + x / 2;
569 data[coff] = cb0.u; data[coff + 1] = cb1.u;
571 data[coff] = cb2.u; data[coff + 1] = cb3.u;
573 let mut coff = voff + x / 2;
574 data[coff] = cb0.v; data[coff + 1] = cb1.v;
576 data[coff] = cb2.v; data[coff + 1] = cb3.v;
589 fn calc_skip_dist(&mut self, in_frm: &NAVideoBuffer<u8>, start: usize, end: usize) {
590 self.skip_dist.clear();
591 if let Some(ref ref_frm) = self.lastfrm {
592 let rystride = ref_frm.get_stride(0);
593 let mut ryoff = ref_frm.get_offset(0) + start * rystride;
594 let rustride = ref_frm.get_stride(1);
595 let mut ruoff = ref_frm.get_offset(1) + start / 2 * rustride;
596 let rvstride = ref_frm.get_stride(2);
597 let mut rvoff = ref_frm.get_offset(2) + start / 2 * rvstride;
598 let (width, _) = ref_frm.get_dimensions(0);
599 let rdata = ref_frm.get_data();
601 let iystride = in_frm.get_stride(0);
602 let mut iyoff = in_frm.get_offset(0) + start * iystride;
603 let iustride = in_frm.get_stride(1);
604 let mut iuoff = in_frm.get_offset(1) + start / 2 * iustride;
605 let ivstride = in_frm.get_stride(2);
606 let mut ivoff = in_frm.get_offset(2) + start / 2 * ivstride;
607 let idata = in_frm.get_data();
609 for _ in (start..end).step_by(4) {
610 for x in (0..width).step_by(4) {
612 let mut roff = ryoff + x;
613 let mut ioff = iyoff + x;
616 let d = i32::from(rdata[roff + i]) - i32::from(idata[ioff + i]);
623 let mut roff = ruoff + x / 2;
624 let mut ioff = iuoff + x / 2;
625 let ud = i32::from(rdata[roff]) - i32::from(idata[ioff]);
627 let ud = i32::from(rdata[roff + 1]) - i32::from(idata[ioff + 1]);
629 roff += rustride; ioff += iustride;
630 let ud = i32::from(rdata[roff]) - i32::from(idata[ioff]);
632 let ud = i32::from(rdata[roff + 1]) - i32::from(idata[ioff + 1]);
635 let mut roff = rvoff + x / 2;
636 let mut ioff = ivoff + x / 2;
637 let vd = i32::from(rdata[roff]) - i32::from(idata[ioff]);
639 let vd = i32::from(rdata[roff + 1]) - i32::from(idata[ioff + 1]);
641 roff += rvstride; ioff += ivstride;
642 let vd = i32::from(rdata[roff]) - i32::from(idata[ioff]);
644 let vd = i32::from(rdata[roff + 1]) - i32::from(idata[ioff + 1]);
647 self.skip_dist.push(dist as u32);
650 iyoff += iystride * 4;
651 iuoff += iustride * 2;
652 ivoff += ivstride * 2;
653 ryoff += rystride * 4;
654 ruoff += rustride * 2;
655 rvoff += rvstride * 2;
661 fn quant_vectors(&mut self) {
664 self.v1_len = elbg_quant(&self.v1_entries, &mut self.v1_cur_cb[self.cur_strip]);
665 self.v4_len = if !self.force_v1 {
666 elbg_quant(&self.v4_entries, &mut self.v4_cur_cb[self.cur_strip])
672 for bin in self.fst_bins.iter_mut() {
675 self.v1_len = quant_fast(&mut self.fst_bins, &self.v1_entries, &mut self.v1_cur_cb[self.cur_strip]);
676 self.v4_len = if !self.force_v1 {
677 quant_fast(&mut self.fst_bins, &self.v4_entries, &mut self.v4_cur_cb[self.cur_strip])
682 QuantMode::MedianCut => {
683 self.v1_len = quantise_median_cut::<YUVCode, YUVCodeSum>(&self.v1_entries, &mut self.v1_cur_cb[self.cur_strip]);
685 self.v4_len = quantise_median_cut::<YUVCode, YUVCodeSum>(&self.v4_entries, &mut self.v4_cur_cb[self.cur_strip]);
692 for e in self.v1_cur_cb[self.cur_strip].iter_mut().skip(self.v1_len) { *e = YUVCode::default(); }
693 for e in self.v4_cur_cb[self.cur_strip].iter_mut().skip(self.v4_len) { *e = YUVCode::default(); }
695 fn encode_intra(&mut self, bw: &mut ByteWriter, in_frm: &NAVideoBuffer<u8>) -> EncoderResult<bool> {
696 let (width, height) = in_frm.get_dimensions(0);
697 let mut strip_h = (height / self.nstrips + 3) & !3;
702 let mut start_line = 0;
703 let mut end_line = strip_h;
705 bw.write_byte(0)?; // intra flag
706 bw.write_u24be(0)?; // frame size
707 let frame_data_pos = bw.tell();
708 bw.write_u16be(width as u16)?;
709 bw.write_u16be(height as u16)?;
710 bw.write_u16be(self.nstrips as u16)?;
713 for entry in self.v1_cb[self.cur_strip].iter_mut() {
714 self.rng.fill_entry(entry);
716 for entry in self.v4_cb[self.cur_strip].iter_mut() {
717 self.rng.fill_entry(entry);
719 while start_line < height {
720 self.read_strip(in_frm, start_line, end_line);
722 if self.cur_strip > 0 {
723 self.v1_cb[self.cur_strip] = self.v1_cb[self.cur_strip - 1];
724 self.v4_cb[self.cur_strip] = self.v4_cb[self.cur_strip - 1];
726 self.quant_vectors();
728 for cw in self.v1_cur_cb[self.cur_strip].iter_mut() {
732 for cw in self.v4_cur_cb[self.cur_strip].iter_mut() {
742 for (v1_entry, v4_entries) in self.v1_entries.iter().zip(self.v4_entries.chunks(4)) {
743 let (v1_idx, v1_dist) = Self::find_nearest(&self.v1_cur_cb[self.cur_strip][..self.v1_len], *v1_entry);
744 if v1_dist == 0 || self.force_v1 {
746 self.v1_idx.push(v1_idx);
749 let (v40_idx, v40_dist) = Self::find_nearest(&self.v4_cur_cb[self.cur_strip][..self.v4_len], v4_entries[0]);
750 let (v41_idx, v41_dist) = Self::find_nearest(&self.v4_cur_cb[self.cur_strip][..self.v4_len], v4_entries[1]);
751 let (v42_idx, v42_dist) = Self::find_nearest(&self.v4_cur_cb[self.cur_strip][..self.v4_len], v4_entries[2]);
752 let (v43_idx, v43_dist) = Self::find_nearest(&self.v4_cur_cb[self.cur_strip][..self.v4_len], v4_entries[3]);
753 if v40_dist + v41_dist + v42_dist + v43_dist > v1_dist {
755 self.v4_idx.push(v40_idx);
756 self.v4_idx.push(v41_idx);
757 self.v4_idx.push(v42_idx);
758 self.v4_idx.push(v43_idx);
761 self.v1_idx.push(v1_idx);
766 let mut is_intra_strip = start_line == 0;
767 let (upd_v1, upd_v4) = if !is_intra_strip {
768 let cb_size = if self.grayscale { 4 } else { 6 };
769 (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),
770 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))
774 if !is_intra_strip && !upd_v1 && !upd_v4 {
775 is_intra_strip = true;
777 bw.write_byte(if is_intra_strip { 0x10 } else { 0x11 })?;
778 bw.write_u24be(0)?; // strip size
779 let strip_data_pos = bw.tell();
780 bw.write_u16be(0)?; // yoff
781 bw.write_u16be(0)?; // xoff
782 bw.write_u16be((end_line - start_line) as u16)?;
783 bw.write_u16be(width as u16)?;
785 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)?;
786 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)?;
788 self.render_stripe(true, start_line, end_line);
790 if self.v4_idx.is_empty() {
791 bw.write_byte(0x32)?;
792 bw.write_u24be((self.v1_idx.len() + 4) as u32)?;
793 bw.write_buf(self.v1_idx.as_slice())?;
795 bw.write_byte(0x30)?;
797 let chunk_pos = bw.tell();
807 for mask in self.masks.masks.iter() {
808 bw.write_u32be(*mask)?;
809 for j in (0..32).rev() {
810 if (mask & (1 << j)) == 0 {
811 bw.write_byte(self.v1_idx[v1_pos])?;
814 bw.write_byte(self.v4_idx[v4_pos])?;
815 bw.write_byte(self.v4_idx[v4_pos + 1])?;
816 bw.write_byte(self.v4_idx[v4_pos + 2])?;
817 bw.write_byte(self.v4_idx[v4_pos + 3])?;
822 patch_size(bw, chunk_pos)?;
825 patch_size(bw, strip_data_pos)?;
827 self.v1_cb[self.cur_strip].copy_from_slice(&self.v1_cur_cb[self.cur_strip]);
828 self.v4_cb[self.cur_strip].copy_from_slice(&self.v4_cur_cb[self.cur_strip]);
829 start_line = end_line;
830 end_line = (end_line + strip_h).min(height);
834 patch_size(bw, frame_data_pos)?;
837 fn encode_inter(&mut self, bw: &mut ByteWriter, in_frm: &NAVideoBuffer<u8>) -> EncoderResult<bool> {
838 let (width, height) = in_frm.get_dimensions(0);
839 let mut strip_h = (height / self.nstrips + 3) & !3;
844 let mut start_line = 0;
845 let mut end_line = strip_h;
847 bw.write_byte(1)?; // intra flag
848 bw.write_u24be(0)?; // frame size
849 let frame_data_pos = bw.tell();
850 bw.write_u16be(width as u16)?;
851 bw.write_u16be(height as u16)?;
852 bw.write_u16be(self.nstrips as u16)?;
855 while start_line < height {
856 self.read_strip(in_frm, start_line, end_line);
857 self.calc_skip_dist(in_frm, start_line, end_line);
859 self.quant_vectors();
861 for cw in self.v1_cur_cb[self.cur_strip].iter_mut() {
865 for cw in self.v4_cur_cb[self.cur_strip].iter_mut() {
875 let mut skip_iter = self.skip_dist.iter();
876 for (v1_entry, v4_entries) in self.v1_entries.iter().zip(self.v4_entries.chunks(4)) {
877 let skip_dist = *skip_iter.next().unwrap();
879 self.masks.put_inter(true);
882 let (v1_idx, v1_dist) = Self::find_nearest(&self.v1_cur_cb[self.cur_strip][..self.v1_len], *v1_entry);
883 if skip_dist < v1_dist {
884 self.masks.put_inter(true);
887 self.masks.put_inter(false);
889 if v1_dist == 0 || self.force_v1 {
891 self.v1_idx.push(v1_idx);
894 let (v40_idx, v40_dist) = Self::find_nearest(&self.v4_cur_cb[self.cur_strip][..self.v4_len], v4_entries[0]);
895 let (v41_idx, v41_dist) = Self::find_nearest(&self.v4_cur_cb[self.cur_strip][..self.v4_len], v4_entries[1]);
896 let (v42_idx, v42_dist) = Self::find_nearest(&self.v4_cur_cb[self.cur_strip][..self.v4_len], v4_entries[2]);
897 let (v43_idx, v43_dist) = Self::find_nearest(&self.v4_cur_cb[self.cur_strip][..self.v4_len], v4_entries[3]);
898 if v40_dist + v41_dist + v42_dist + v43_dist > v1_dist {
900 self.v4_idx.push(v40_idx);
901 self.v4_idx.push(v41_idx);
902 self.v4_idx.push(v42_idx);
903 self.v4_idx.push(v43_idx);
906 self.v1_idx.push(v1_idx);
911 let (upd_v1, upd_v4) = {
912 let cb_size = if self.grayscale { 4 } else { 6 };
913 (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),
914 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))
916 bw.write_byte(0x11)?;
917 bw.write_u24be(0)?; // strip size
918 let strip_data_pos = bw.tell();
919 bw.write_u16be(0)?; // yoff
920 bw.write_u16be(0)?; // xoff
921 bw.write_u16be((end_line - start_line) as u16)?;
922 bw.write_u16be(width as u16)?;
924 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)?;
925 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)?;
927 self.render_stripe(false, start_line, end_line);
929 bw.write_byte(0x31)?;
931 let chunk_pos = bw.tell();
942 for mask in self.masks.masks.iter() {
943 bw.write_u32be(*mask)?;
944 if *mask == 0 && skip { continue; }
945 let mut bit = 1 << 31;
948 skip = (mask & bit) == 0;
951 if (mask & bit) == 0 {
952 bw.write_byte(self.v1_idx[v1_pos])?;
955 bw.write_byte(self.v4_idx[v4_pos])?;
956 bw.write_byte(self.v4_idx[v4_pos + 1])?;
957 bw.write_byte(self.v4_idx[v4_pos + 2])?;
958 bw.write_byte(self.v4_idx[v4_pos + 3])?;
966 patch_size(bw, chunk_pos)?;
968 patch_size(bw, strip_data_pos)?;
970 self.v1_cb[self.cur_strip].copy_from_slice(&self.v1_cur_cb[self.cur_strip]);
971 self.v4_cb[self.cur_strip].copy_from_slice(&self.v4_cur_cb[self.cur_strip]);
972 start_line = end_line;
973 end_line = (end_line + strip_h).min(height);
977 patch_size(bw, frame_data_pos)?;
982 impl NAEncoder for CinepakEncoder {
983 fn negotiate_format(&self, encinfo: &EncodeParameters) -> EncoderResult<EncodeParameters> {
984 match encinfo.format {
985 NACodecTypeInfo::None => {
986 Ok(EncodeParameters {
987 format: NACodecTypeInfo::Video(NAVideoInfo::new(0, 0, true, YUV420_FORMAT)),
991 NACodecTypeInfo::Audio(_) => Err(EncoderError::FormatError),
992 NACodecTypeInfo::Video(vinfo) => {
993 let pix_fmt = if vinfo.format == GRAY_FORMAT { GRAY_FORMAT } else { YUV420_FORMAT };
994 let outinfo = NAVideoInfo::new((vinfo.width + 3) & !3, (vinfo.height + 3) & !3, false, pix_fmt);
995 let mut ofmt = *encinfo;
996 ofmt.format = NACodecTypeInfo::Video(outinfo);
1001 fn get_capabilities(&self) -> u64 { 0 }
1002 fn init(&mut self, stream_id: u32, encinfo: EncodeParameters) -> EncoderResult<NAStreamRef> {
1003 match encinfo.format {
1004 NACodecTypeInfo::None => Err(EncoderError::FormatError),
1005 NACodecTypeInfo::Audio(_) => Err(EncoderError::FormatError),
1006 NACodecTypeInfo::Video(vinfo) => {
1007 if vinfo.format != YUV420_FORMAT && vinfo.format != GRAY_FORMAT {
1008 return Err(EncoderError::FormatError);
1010 if ((vinfo.width | vinfo.height) & 3) != 0 {
1011 return Err(EncoderError::FormatError);
1013 if (vinfo.width | vinfo.height) >= (1 << 16) {
1014 return Err(EncoderError::FormatError);
1017 let out_info = NAVideoInfo::new(vinfo.width, vinfo.height, false, vinfo.format);
1018 let info = NACodecInfo::new("cinepak", NACodecTypeInfo::Video(out_info), None);
1019 let mut stream = NAStream::new(StreamType::Video, stream_id, info, encinfo.tb_num, encinfo.tb_den, 0);
1020 stream.set_num(stream_id as usize);
1021 let stream = stream.into_ref();
1023 self.stream = Some(stream.clone());
1024 self.quality = encinfo.quality;
1025 self.grayscale = vinfo.format != YUV420_FORMAT;
1026 let num_blocks = vinfo.width / 2 * vinfo.height / 2;
1027 self.v1_entries = Vec::with_capacity(num_blocks);
1028 self.v4_entries = Vec::with_capacity(num_blocks * 4);
1029 self.v1_idx = Vec::with_capacity(num_blocks);
1030 self.v4_idx = Vec::with_capacity(num_blocks * 4);
1031 self.skip_dist = Vec::with_capacity(vinfo.width / 4 * vinfo.height / 4);
1033 let buf = alloc_video_buffer(out_info, 2)?;
1034 self.lastfrm = Some(buf.get_vbuf().unwrap());
1040 fn encode(&mut self, frm: &NAFrame) -> EncoderResult<()> {
1041 let buf = frm.get_buffer();
1042 if let Some(ref vbuf) = buf.get_vbuf() {
1043 if self.nstrips == 0 {
1044 let (w, h) = vbuf.get_dimensions(0);
1045 self.nstrips = ((((w * h) >> 4) + 1200) / 2400).max(1).min(3);
1046 let strip_h = ((h + self.nstrips - 1) / self.nstrips + 3) & !3;
1047 self.nstrips = (h + strip_h - 1) / strip_h;
1049 let cur_strips = self.v1_cb.len();
1050 if cur_strips != self.nstrips {
1053 if cur_strips < self.nstrips {
1054 for _ in cur_strips..self.nstrips {
1055 self.v1_cb.push([YUVCode::default(); 256]);
1056 self.v4_cb.push([YUVCode::default(); 256]);
1057 self.v1_cur_cb.push([YUVCode::default(); 256]);
1058 self.v4_cur_cb.push([YUVCode::default(); 256]);
1062 let mut dbuf = Vec::with_capacity(4);
1063 let mut gw = GrowableMemoryWriter::new_write(&mut dbuf);
1064 let mut bw = ByteWriter::new(&mut gw);
1065 let is_intra = if self.frmcount == 0 {
1066 self.encode_intra(&mut bw, vbuf)?
1068 self.encode_inter(&mut bw, vbuf)?
1070 self.pkt = Some(NAPacket::new(self.stream.clone().unwrap(), frm.ts, is_intra, dbuf));
1072 if self.frmcount == self.key_int {
1077 Err(EncoderError::InvalidParameters)
1080 fn get_packet(&mut self) -> EncoderResult<Option<NAPacket>> {
1081 let mut npkt = None;
1082 std::mem::swap(&mut self.pkt, &mut npkt);
1085 fn flush(&mut self) -> EncoderResult<()> {
1091 const ENCODER_OPTS: &[NAOptionDefinition] = &[
1092 NAOptionDefinition {
1093 name: KEYFRAME_OPTION, description: KEYFRAME_OPTION_DESC,
1094 opt_type: NAOptionDefinitionType::Int(Some(0), Some(128)) },
1095 NAOptionDefinition {
1096 name: "nstrips", description: "Number of strips per frame (0 - automatic)",
1097 opt_type: NAOptionDefinitionType::Int(Some(0), Some(16)) },
1098 NAOptionDefinition {
1099 name: "quant_mode", description: "Quantisation mode",
1100 opt_type: NAOptionDefinitionType::String(Some(&["elbg", "fast", "mediancut"])) },
1101 NAOptionDefinition {
1102 name: "force_v1", description: "Force coarse (V1-only) mode",
1103 opt_type: NAOptionDefinitionType::Bool },
1106 impl NAOptionHandler for CinepakEncoder {
1107 fn get_supported_options(&self) -> &[NAOptionDefinition] { ENCODER_OPTS }
1108 fn set_options(&mut self, options: &[NAOption]) {
1109 for option in options.iter() {
1110 for opt_def in ENCODER_OPTS.iter() {
1111 if opt_def.check(option).is_ok() {
1113 KEYFRAME_OPTION => {
1114 if let NAValue::Int(intval) = option.value {
1115 self.key_int = intval as u8;
1119 if let NAValue::Int(intval) = option.value {
1120 self.nstrips = intval as usize;
1124 if let NAValue::String(ref strval) = option.value {
1125 match strval.as_str() {
1126 "elbg" => self.qmode = QuantMode::ELBG,
1127 "fast" => self.qmode = QuantMode::Fast,
1128 "mediancut" => self.qmode = QuantMode::MedianCut,
1134 if let NAValue::Bool(val) = option.value {
1135 self.force_v1 = val;
1144 fn query_option_value(&self, name: &str) -> Option<NAValue> {
1146 KEYFRAME_OPTION => Some(NAValue::Int(i64::from(self.key_int))),
1147 "nstrips" => Some(NAValue::Int(self.nstrips as i64)),
1148 "quant_mode" => Some(NAValue::String(self.qmode.to_string())),
1149 "force_v1" => Some(NAValue::Bool(self.force_v1)),
1155 pub fn get_encoder() -> Box<dyn NAEncoder + Send> {
1156 Box::new(CinepakEncoder::new())
1161 use nihav_core::codecs::*;
1162 use nihav_core::demuxers::*;
1163 use nihav_core::muxers::*;
1165 use nihav_codec_support::test::enc_video::*;
1168 fn test_cinepak_encoder() {
1169 let mut dmx_reg = RegisteredDemuxers::new();
1170 generic_register_all_demuxers(&mut dmx_reg);
1171 let mut dec_reg = RegisteredDecoders::new();
1172 generic_register_all_decoders(&mut dec_reg);
1173 let mut mux_reg = RegisteredMuxers::new();
1174 generic_register_all_muxers(&mut mux_reg);
1175 let mut enc_reg = RegisteredEncoders::new();
1176 generic_register_all_encoders(&mut enc_reg);
1178 // sample: https://samples.mplayerhq.hu/V-codecs/UCOD/TalkingHead_352x288.avi
1179 let dec_config = DecoderTestParams {
1181 in_name: "assets/Misc/TalkingHead_352x288.avi",
1182 stream_type: StreamType::Video,
1186 let enc_config = EncoderTestParams {
1188 enc_name: "cinepak",
1189 out_name: "cinepak.avi",
1192 let dst_vinfo = NAVideoInfo {
1195 format: YUV420_FORMAT,
1199 let enc_params = EncodeParameters {
1200 format: NACodecTypeInfo::Video(dst_vinfo),
1207 let enc_options = &[
1208 NAOption { name: "quant_mode", value: NAValue::String("mediancut".to_string()) },
1210 //test_encoding_to_file(&dec_config, &enc_config, enc_params, enc_options);
1211 test_encoding_md5(&dec_config, &enc_config, enc_params, enc_options,
1212 &[0x1d4690c8, 0x3b15b4b3, 0xc2df3c7b, 0x1a25b159]);