1 use nihav_core::codecs::*;
2 use nihav_core::compr::deflate::{Deflate, DeflateMode, DeflateWriter};
3 use nihav_core::io::byteio::*;
5 const RGB555_FORMAT: NAPixelFormaton = NAPixelFormaton { model: ColorModel::RGB(RGBSubmodel::RGB), components: 3,
7 Some(NAPixelChromaton{ h_ss: 0, v_ss: 0, packed: true, depth: 5, shift: 10, comp_offs: 0, next_elem: 2 }),
8 Some(NAPixelChromaton{ h_ss: 0, v_ss: 0, packed: true, depth: 5, shift: 5, comp_offs: 0, next_elem: 2 }),
9 Some(NAPixelChromaton{ h_ss: 0, v_ss: 0, packed: true, depth: 5, shift: 0, comp_offs: 0, next_elem: 2 }),
11 elem_size: 2, be: false, alpha: false, palette: false };
12 const RGB24_0_FORMAT: NAPixelFormaton = NAPixelFormaton { model: ColorModel::RGB(RGBSubmodel::RGB), components: 3,
14 Some(NAPixelChromaton{ h_ss: 0, v_ss: 0, packed: true, depth: 8, shift: 0, comp_offs: 2, next_elem: 4 }),
15 Some(NAPixelChromaton{ h_ss: 0, v_ss: 0, packed: true, depth: 8, shift: 0, comp_offs: 1, next_elem: 4 }),
16 Some(NAPixelChromaton{ h_ss: 0, v_ss: 0, packed: true, depth: 8, shift: 0, comp_offs: 0, next_elem: 4 }),
18 elem_size: 4, be: false, alpha: false, palette: false };
21 stream: Option<NAStreamRef>,
27 pkt: Option<NAPacket>,
40 fn buf_type_to_bpp(buf: &NABufferType) -> u8 {
42 NABufferType::Video(ref vbuf) => {
43 let vinfo = vbuf.get_info();
44 if vinfo.get_format().is_paletted() {
47 vinfo.get_format().get_total_depth()
50 NABufferType::VideoPacked(ref vbuf) => {
51 let vinfo = vbuf.get_info();
52 vinfo.get_format().elem_size * 8
54 NABufferType::Video16(ref vbuf) => {
55 let vinfo = vbuf.get_info();
56 vinfo.get_format().get_total_depth()
62 fn copy_frame(buf: NABufferType, dst: &mut [u8], bpp: u8) -> EncoderResult<()> {
64 NABufferType::Video(ref vbuf) => {
66 return Err(EncoderError::FormatError);
68 let off = vbuf.get_offset(0);
69 let stride = vbuf.get_stride(0);
70 let data = vbuf.get_data();
71 let w = vbuf.get_info().get_width();
72 let h = vbuf.get_info().get_height();
74 for (dline, sline) in dst.chunks_mut(w).zip(data[off..].chunks(stride)).take(h) {
75 dline[..w].copy_from_slice(&sline[..w]);
78 NABufferType::Video16(ref vbuf) => {
79 let off = vbuf.get_offset(0);
80 let stride = vbuf.get_stride(0);
81 let data = vbuf.get_data();
82 let w = vbuf.get_info().get_width();
83 let h = vbuf.get_info().get_height();
85 for (dline, sline) in dst.chunks_mut(w * 2).zip(data[off..].chunks(stride)).take(h) {
86 for (dst, &src) in dline[..w * 2].chunks_exact_mut(2).zip(sline.iter()) {
88 dst[1] = (src >> 8) as u8;
92 NABufferType::VideoPacked(ref vbuf) => {
93 let off = vbuf.get_offset(0);
94 let stride = vbuf.get_stride(0);
95 let data = vbuf.get_data();
96 let w = vbuf.get_info().get_width();
97 let h = vbuf.get_info().get_height();
98 let w = w * (((bpp as usize) + 7) / 8);
100 for (dline, sline) in dst.chunks_mut(w).zip(data[off..].chunks(stride)).take(h) {
101 dline[..w].copy_from_slice(&sline[..w]);
104 _ => return Err(EncoderError::FormatError),
109 fn to_signed(val: usize) -> isize {
113 -((val >> 1) as isize) - 1
131 cmode: DeflateMode::default(),
132 compr: Deflate::new(DeflateMode::default()),
139 fn encode_intra(&mut self, bw: &mut ByteWriter, buf: NABufferType) -> EncoderResult<()> {
140 let bpp = buf_type_to_bpp(&buf);
142 if let NABufferType::None = buf {
144 return Err(EncoderError::FormatError);
146 self.frm1.copy_from_slice(&self.frm2);
149 return Err(EncoderError::FormatError);
153 if let (NABufferType::Video(ref vbuf), true) = (&buf, bpp == 8) {
154 let off = vbuf.get_offset(1);
155 let data = vbuf.get_data();
156 self.pal.copy_from_slice(&data[off..][..768]);
159 copy_frame(buf, &mut self.frm1, self.bpp)?;
162 bw.write_byte(1)?; // intra flag
163 bw.write_byte(0)?; // high version
164 bw.write_byte(1)?; // low version
165 bw.write_byte(if self.cmode == DeflateMode::NoCompr { 0 } else { 1 })?;
166 let fmt = match self.bpp {
175 bw.write_byte(self.tile_w as u8)?;
176 bw.write_byte(self.tile_h as u8)?;
178 let bm = ((bpp as usize) + 7) / 8;
179 if self.cmode == DeflateMode::NoCompr {
181 bw.write_buf(&self.pal)?;
183 bw.write_buf(&self.frm1[..self.width * self.height * bm])?;
185 self.tmp_buf.truncate(0);
187 self.tmp_buf.extend_from_slice(&self.pal);
189 self.tmp_buf.extend_from_slice(&self.frm1[..self.width * self.height * bm]);
190 self.compr = Deflate::new(self.cmode);
192 let mut db = Vec::new();
193 std::mem::swap(&mut db, &mut self.zbuf);
195 let mut wr = DeflateWriter::new(db);
196 self.compr.write_zlib_header(&mut wr);
197 self.compr.compress(&self.tmp_buf, &mut wr);
198 self.compr.compress_flush(&mut wr);
199 let mut db = wr.end();
200 std::mem::swap(&mut db, &mut self.zbuf);
202 bw.write_buf(&self.zbuf)?;
207 fn encode_inter(&mut self, bw: &mut ByteWriter, buf: NABufferType) -> EncoderResult<()> {
208 if let NABufferType::None = buf {
209 self.frm1.copy_from_slice(&self.frm2);
212 self.tmp_buf.truncate(0);
213 let tile_w = (self.width + self.tile_w - 1) / self.tile_w;
214 let tile_h = (self.height + self.tile_h - 1) / self.tile_h;
215 let mv_size = (tile_w * tile_h * 2 + 3) & !3;
216 for _ in 0..mv_size {
217 self.tmp_buf.push(0);
219 if self.cmode == DeflateMode::NoCompr {
220 bw.write_buf(&self.tmp_buf)?;
222 let mut db = Vec::new();
224 std::mem::swap(&mut db, &mut self.zbuf);
226 let mut wr = DeflateWriter::new(db);
227 self.compr.compress(&self.tmp_buf, &mut wr);
228 self.compr.compress_flush(&mut wr);
229 let mut db = wr.end();
230 std::mem::swap(&mut db, &mut self.zbuf);
232 bw.write_buf(&self.zbuf)?;
236 let bpp = buf_type_to_bpp(&buf);
237 if bpp == 0 || bpp != self.bpp {
238 return Err(EncoderError::FormatError);
241 self.tmp_buf.truncate(0);
242 if let (NABufferType::Video(ref vbuf), true) = (&buf, bpp == 8) {
243 let mut npal = [0; 768];
244 let off = vbuf.get_offset(1);
245 let data = vbuf.get_data();
246 npal.copy_from_slice(&data[off..][..768]);
248 for (&a, &b) in self.pal.iter().zip(npal.iter()) {
255 for (&a, &b) in self.pal.iter().zip(npal.iter()) {
256 self.tmp_buf.push(a ^ b);
267 copy_frame(buf, &mut self.frm1, self.bpp)?;
269 let tile_w = (self.width + self.tile_w - 1) / self.tile_w;
270 let tile_h = (self.height + self.tile_h - 1) / self.tile_h;
271 let mut mv_start = self.tmp_buf.len();
272 let mv_size = (tile_w * tile_h * 2 + 3) & !3;
273 for _ in 0..mv_size {
274 self.tmp_buf.push(0);
277 let bpp = ((self.bpp as usize) + 7) / 8;
278 let stride = self.width * bpp;
280 for y in (0..self.height).step_by(self.tile_h) {
281 let cur_h = (self.height - y).min(self.tile_h);
282 for x in (0..self.width).step_by(self.tile_w) {
283 let cur_w = (self.width - x).min(self.tile_w);
285 let mut best_dist = std::u32::MAX;
289 'search: for yoff in 0..self.range {
290 let ypos = (y as isize) + to_signed(yoff);
294 let ypos = ypos as usize;
295 if ypos + cur_h > self.height {
298 for xoff in 0..self.range {
299 let xpos = (x as isize) + to_signed(xoff);
303 let xpos = xpos as usize;
304 if xpos + cur_w > self.width {
309 let roff = xpos * bpp + ypos * stride;
310 for (line0, line1) in self.frm1[off..].chunks(stride).take(cur_h).zip(self.frm2[roff..].chunks(stride)) {
311 for (&a, &b) in line0[..cur_w * bpp].iter().zip(line1[..cur_w * bpp].iter()) {
312 diff += u32::from(a ^ b);
316 if best_dist > diff {
327 let has_delta = best_dist != 0;
328 self.tmp_buf[mv_start] = (best_x.wrapping_sub(x) << 1) as u8;
330 self.tmp_buf[mv_start] |= 1;
332 self.tmp_buf[mv_start + 1] = (best_y.wrapping_sub(y) << 1) as u8;
335 let rpos = best_x * bpp + best_y * stride;
336 for (line0, line1) in self.frm1[off..].chunks(stride).take(cur_h).zip(self.frm2[rpos..].chunks(stride)) {
337 for (&a, &b) in line0[..cur_w * bpp].iter().zip(line1[..cur_w * bpp].iter()) {
338 self.tmp_buf.push(a ^ b);
343 off += self.tile_w * bpp;
345 off -= tile_w * self.tile_w * bpp;
346 off += stride * self.tile_h;
349 if self.cmode == DeflateMode::NoCompr {
350 bw.write_buf(&self.tmp_buf)?;
352 let mut db = Vec::new();
354 std::mem::swap(&mut db, &mut self.zbuf);
356 let mut wr = DeflateWriter::new(db);
357 self.compr.compress(&self.tmp_buf, &mut wr);
358 self.compr.compress_flush(&mut wr);
359 let mut db = wr.end();
360 std::mem::swap(&mut db, &mut self.zbuf);
362 bw.write_buf(&self.zbuf)?;
369 impl NAEncoder for ZMBVEncoder {
370 fn negotiate_format(&self, encinfo: &EncodeParameters) -> EncoderResult<EncodeParameters> {
371 match encinfo.format {
372 NACodecTypeInfo::None => {
373 let mut ofmt = EncodeParameters::default();
374 ofmt.format = NACodecTypeInfo::Video(NAVideoInfo::new(0, 0, true, YUV420_FORMAT));
377 NACodecTypeInfo::Audio(_) => Err(EncoderError::FormatError),
378 NACodecTypeInfo::Video(vinfo) => {
379 let depth = vinfo.format.get_total_depth();
380 let pix_fmt = if vinfo.format.is_paletted() {
382 } else if !vinfo.format.model.is_rgb() || depth > 16 {
384 } else if depth < 16 {
389 let outinfo = NAVideoInfo::new(vinfo.width, vinfo.height, false, pix_fmt);
390 let mut ofmt = *encinfo;
391 ofmt.format = NACodecTypeInfo::Video(outinfo);
396 fn init(&mut self, stream_id: u32, encinfo: EncodeParameters) -> EncoderResult<NAStreamRef> {
397 match encinfo.format {
398 NACodecTypeInfo::None => Err(EncoderError::FormatError),
399 NACodecTypeInfo::Audio(_) => Err(EncoderError::FormatError),
400 NACodecTypeInfo::Video(vinfo) => {
401 self.width = vinfo.width;
402 self.height = vinfo.height;
404 let out_info = NAVideoInfo::new(vinfo.width, vinfo.height, false, vinfo.format);
405 let info = NACodecInfo::new("zmbv", NACodecTypeInfo::Video(out_info), None);
406 let mut stream = NAStream::new(StreamType::Video, stream_id, info, encinfo.tb_num, encinfo.tb_den, 0);
407 stream.set_num(stream_id as usize);
408 let stream = stream.into_ref();
410 self.stream = Some(stream.clone());
412 self.frm1 = vec![0; vinfo.width * vinfo.height * 4];
413 self.frm2 = vec![0; vinfo.width * vinfo.height * 4];
419 fn encode(&mut self, frm: &NAFrame) -> EncoderResult<()> {
420 let buf = frm.get_buffer();
421 let mut dbuf = Vec::with_capacity(4);
422 let mut gw = GrowableMemoryWriter::new_write(&mut dbuf);
423 let mut bw = ByteWriter::new(&mut gw);
424 let is_intra = if self.frmcount == 0 {
425 self.encode_intra(&mut bw, buf)?;
428 self.encode_inter(&mut bw, buf)?;
431 self.pkt = Some(NAPacket::new(self.stream.clone().unwrap(), frm.ts, is_intra, dbuf));
433 if self.frmcount == self.key_int {
436 std::mem::swap(&mut self.frm1, &mut self.frm2);
439 fn get_packet(&mut self) -> EncoderResult<Option<NAPacket>> {
441 std::mem::swap(&mut self.pkt, &mut npkt);
444 fn flush(&mut self) -> EncoderResult<()> {
450 const ENCODER_OPTS: &[NAOptionDefinition] = &[
452 name: KEYFRAME_OPTION, description: KEYFRAME_OPTION_DESC,
453 opt_type: NAOptionDefinitionType::Int(Some(0), Some(128)) },
455 name: "range", description: "Block search range (0-128)",
456 opt_type: NAOptionDefinitionType::Int(Some(0), Some(128)) },
458 name: "tile_width", description: "Block width (1-255)",
459 opt_type: NAOptionDefinitionType::Int(Some(1), Some(255)) },
461 name: "tile_height", description: "Block width (1-255)",
462 opt_type: NAOptionDefinitionType::Int(Some(1), Some(255)) },
464 name: "compr_level", description: "Compression level",
465 opt_type: DEFLATE_OPTION_VALUES },
468 impl NAOptionHandler for ZMBVEncoder {
469 fn get_supported_options(&self) -> &[NAOptionDefinition] { ENCODER_OPTS }
470 fn set_options(&mut self, options: &[NAOption]) {
471 for option in options.iter() {
472 for opt_def in ENCODER_OPTS.iter() {
473 if opt_def.check(option).is_ok() {
476 if let NAValue::String(ref s) = option.value {
477 if let Ok(val) = s.parse::<DeflateMode>() {
483 if let NAValue::Int(intval) = option.value {
484 self.key_int = intval as u8;
488 if let NAValue::Int(intval) = option.value {
489 self.range = intval as usize;
493 if let NAValue::Int(intval) = option.value {
494 self.tile_w = intval as usize;
498 if let NAValue::Int(intval) = option.value {
499 self.tile_h = intval as usize;
508 fn query_option_value(&self, name: &str) -> Option<NAValue> {
510 "compr_level" => Some(NAValue::String(self.cmode.to_string())),
511 KEYFRAME_OPTION => Some(NAValue::Int(i64::from(self.key_int))),
512 "range" => Some(NAValue::Int(self.range as i64)),
513 "tile_width" => Some(NAValue::Int(self.tile_w as i64)),
514 "tile_height" => Some(NAValue::Int(self.tile_h as i64)),
520 pub fn get_encoder() -> Box<dyn NAEncoder + Send> {
521 Box::new(ZMBVEncoder::new())
526 use nihav_core::codecs::*;
527 use nihav_core::demuxers::*;
528 use nihav_core::muxers::*;
530 use nihav_codec_support::test::enc_video::*;
531 use super::{RGB555_FORMAT, RGB24_0_FORMAT};
534 fn test_zmbv_encoder_8bit() {
535 let mut dmx_reg = RegisteredDemuxers::new();
536 generic_register_all_demuxers(&mut dmx_reg);
537 let mut dec_reg = RegisteredDecoders::new();
538 generic_register_all_decoders(&mut dec_reg);
539 let mut mux_reg = RegisteredMuxers::new();
540 generic_register_all_muxers(&mut mux_reg);
541 let mut enc_reg = RegisteredEncoders::new();
542 generic_register_all_encoders(&mut enc_reg);
544 let dec_config = DecoderTestParams {
546 in_name: "assets/Misc/td3_000.avi",
547 stream_type: StreamType::Video,
551 let enc_config = EncoderTestParams {
554 out_name: "zmbv8.avi",
557 let dst_vinfo = NAVideoInfo {
564 let enc_params = EncodeParameters {
565 format: NACodecTypeInfo::Video(dst_vinfo),
572 //test_encoding_to_file(&dec_config, &enc_config, enc_params);
573 test_encoding_md5(&dec_config, &enc_config, enc_params,
574 &[0x50df10e2, 0x606f3268, 0xdd4bc2ff, 0x844e7d87]);
578 fn test_zmbv_encoder_15bit() {
579 let mut dmx_reg = RegisteredDemuxers::new();
580 generic_register_all_demuxers(&mut dmx_reg);
581 let mut dec_reg = RegisteredDecoders::new();
582 generic_register_all_decoders(&mut dec_reg);
583 let mut mux_reg = RegisteredMuxers::new();
584 generic_register_all_muxers(&mut mux_reg);
585 let mut enc_reg = RegisteredEncoders::new();
586 generic_register_all_encoders(&mut enc_reg);
588 let dec_config = DecoderTestParams {
590 in_name: "assets/Misc/zmbv_15bit.avi",
591 stream_type: StreamType::Video,
595 let enc_config = EncoderTestParams {
598 out_name: "zmbv15.avi",
601 let dst_vinfo = NAVideoInfo {
604 format: RGB555_FORMAT,
608 let enc_params = EncodeParameters {
609 format: NACodecTypeInfo::Video(dst_vinfo),
616 //test_encoding_to_file(&dec_config, &enc_config, enc_params);
617 test_encoding_md5(&dec_config, &enc_config, enc_params,
618 &[0x0b4cb528, 0x66c91f6c, 0x1c2187a5, 0x2723a08d]);
622 fn test_zmbv_encoder_16bit() {
623 let mut dmx_reg = RegisteredDemuxers::new();
624 generic_register_all_demuxers(&mut dmx_reg);
625 let mut dec_reg = RegisteredDecoders::new();
626 generic_register_all_decoders(&mut dec_reg);
627 let mut mux_reg = RegisteredMuxers::new();
628 generic_register_all_muxers(&mut mux_reg);
629 let mut enc_reg = RegisteredEncoders::new();
630 generic_register_all_encoders(&mut enc_reg);
632 let dec_config = DecoderTestParams {
634 in_name: "assets/Misc/zmbv_16bit.avi",
635 stream_type: StreamType::Video,
639 let enc_config = EncoderTestParams {
642 out_name: "zmbv16.avi",
645 let dst_vinfo = NAVideoInfo {
648 format: RGB565_FORMAT,
652 let enc_params = EncodeParameters {
653 format: NACodecTypeInfo::Video(dst_vinfo),
660 //test_encoding_to_file(&dec_config, &enc_config, enc_params);
661 test_encoding_md5(&dec_config, &enc_config, enc_params,
662 &[0x1a522743, 0x6c320a6e, 0xd08539e1, 0x03fc17ea]);
666 fn test_zmbv_encoder_32bit() {
667 let mut dmx_reg = RegisteredDemuxers::new();
668 generic_register_all_demuxers(&mut dmx_reg);
669 let mut dec_reg = RegisteredDecoders::new();
670 generic_register_all_decoders(&mut dec_reg);
671 let mut mux_reg = RegisteredMuxers::new();
672 generic_register_all_muxers(&mut mux_reg);
673 let mut enc_reg = RegisteredEncoders::new();
674 generic_register_all_encoders(&mut enc_reg);
676 let dec_config = DecoderTestParams {
678 in_name: "assets/Misc/zmbv_32bit.avi",
679 stream_type: StreamType::Video,
683 let enc_config = EncoderTestParams {
686 out_name: "zmbv32.avi",
689 let dst_vinfo = NAVideoInfo {
692 format: RGB24_0_FORMAT,
696 let enc_params = EncodeParameters {
697 format: NACodecTypeInfo::Video(dst_vinfo),
704 //test_encoding_to_file(&dec_config, &enc_config, enc_params);
705 test_encoding_md5(&dec_config, &enc_config, enc_params,
706 &[0x3880e045, 0xe6c88dc7, 0x21066058, 0xc789f1e9]);