1 use nihav_core::codecs::*;
2 use nihav_core::io::byteio::*;
3 use nihav_core::io::bitwriter::*;
5 const GRAY_FORMAT: NAPixelFormaton = NAPixelFormaton {
6 model: ColorModel::YUV(YUVSubmodel::YUVJ),
8 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],
15 #[derive(Clone,Copy,Default,PartialEq)]
16 enum CompressionLevel {
23 impl std::string::ToString for CompressionLevel {
24 fn to_string(&self) -> String {
26 CompressionLevel::None => "none".to_string(),
27 CompressionLevel::Fast => "fast".to_string(),
28 CompressionLevel::Best => "best".to_string(),
33 const NO_CODE: u16 = 0;
35 struct LZWDictionary {
41 trie: Vec<[u16; 257]>,
47 trie: Vec::with_capacity(4096),
55 fn init(&mut self, bits: u8) {
56 self.cur_size = (1 << bits) + 2;
57 self.bit_len = bits + 1;
58 self.clear_code = 1 << bits;
59 self.end_code = self.clear_code + 1;
60 self.orig_len = self.bit_len;
63 for _ in 0..self.cur_size {
64 self.trie.push([NO_CODE; 257]);
66 for (idx, nodes) in self.trie.iter_mut().enumerate() {
67 nodes[256] = idx as u16;
70 fn find(&self, src: &[u8]) -> (u16, usize, usize) {
71 let mut idx = usize::from(src[0]);
73 for (pos, &next) in src.iter().enumerate().skip(1) {
74 let next = usize::from(next);
75 if self.trie[idx][next] != NO_CODE {
76 idx = usize::from(self.trie[idx][next]);
78 return (self.trie[idx][256], pos, idx);
82 (self.trie[idx][256], last_len + 1, idx)
84 fn add(&mut self, lastidx: usize, next: u8) {
85 if self.cur_size >= (1 << 12) {
88 let next = usize::from(next);
89 if self.trie[lastidx][next] == NO_CODE {
90 let newnode = self.trie.len();
91 self.trie.push([NO_CODE; 257]);
92 self.trie[newnode][256] = self.cur_size as u16;
93 self.trie[lastidx][next] = newnode as u16;
95 if (self.cur_size & (self.cur_size - 1)) == 0 && self.bit_len < 12 {
100 fn reset(&mut self) {
101 self.bit_len = self.orig_len;
102 self.cur_size = usize::from(self.end_code) + 1;
103 self.trie.truncate(self.cur_size);
104 for nodes in self.trie.iter_mut() {
105 for el in nodes[..256].iter_mut() {
114 level: CompressionLevel,
121 dict: LZWDictionary::new(),
122 level: CompressionLevel::default(),
126 fn compress(&mut self, writer: &mut ByteWriter, src: &[u8]) -> EncoderResult<()> {
127 let clr_bits: u8 = if self.level != CompressionLevel::None {
128 let maxclr = u16::from(src.iter().fold(0u8, |acc, &a| acc.max(a))) + 1;
130 while (1 << bits) < maxclr {
136 self.dict.init(clr_bits);
139 let mut tbuf = Vec::new();
140 std::mem::swap(&mut tbuf, &mut self.tmp);
141 let mut bw = BitWriter::new(tbuf, BitWriterMode::LE);
143 bw.write(u32::from(self.dict.clear_code), self.dict.bit_len);
146 CompressionLevel::None => {
147 let sym_limit = 1 << (clr_bits + 1);
148 for &b in src.iter() {
149 if self.dict.cur_size >= sym_limit {
150 bw.write(u32::from(self.dict.clear_code), self.dict.bit_len);
153 bw.write(u32::from(b), self.dict.bit_len);
154 self.dict.add(usize::from(b), 0);
157 CompressionLevel::Fast => {
159 while pos < src.len() {
160 let (idx, len, trieidx) = self.dict.find(&src[pos..]);
161 bw.write(u32::from(idx), self.dict.bit_len);
164 self.dict.add(trieidx, src[pos]);
166 if self.dict.cur_size == 4096 {
167 bw.write(u32::from(self.dict.clear_code), self.dict.bit_len);
172 CompressionLevel::Best => {
174 let mut hist = [0; 16];
178 while pos < src.len() {
179 let (idx, len, trieidx) = self.dict.find(&src[pos..]);
180 bw.write(u32::from(idx), self.dict.bit_len);
182 if pos >= src.len() {
185 self.dict.add(trieidx, src[pos]);
187 avg1 -= hist[(hpos + 1) & 0xF];
189 if self.dict.cur_size == 4096 && (avg1 < avg - avg / 8) {
190 bw.write(u32::from(self.dict.clear_code), self.dict.bit_len);
194 hpos = (hpos + 1) & 0xF;
200 bw.write(u32::from(self.dict.end_code), self.dict.bit_len);
202 std::mem::swap(&mut tbuf, &mut self.tmp);
204 writer.write_byte(clr_bits)?;
205 for chunk in self.tmp.chunks(255) {
206 writer.write_byte(chunk.len() as u8)?;
207 writer.write_buf(chunk)?;
209 writer.write_byte(0x00)?; // data end marker
215 stream: Option<NAStreamRef>,
220 pkt: Option<NAPacket>,
236 prev_frm: Vec::new(),
243 lzw: LZWEncoder::new(),
248 fn write_dummy_frame(&mut self, bw: &mut ByteWriter) -> EncoderResult<()> {
249 let mut pix = [self.cur_frm[0]];
250 if let (true, Some(tr_idx)) = (self.p_trans, self.tr_idx) {
256 // 1x1 image descriptor
257 bw.write_buf(&[0x2C, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x01, 0x00, 0x00])?;
258 self.lzw.compress(bw, &pix)?;
263 impl NAEncoder for GIFEncoder {
264 fn negotiate_format(&self, encinfo: &EncodeParameters) -> EncoderResult<EncodeParameters> {
265 match encinfo.format {
266 NACodecTypeInfo::None => {
267 Ok(EncodeParameters {
268 format: NACodecTypeInfo::Video(NAVideoInfo::new(0, 0, true, YUV420_FORMAT)),
272 NACodecTypeInfo::Audio(_) => Err(EncoderError::FormatError),
273 NACodecTypeInfo::Video(vinfo) => {
274 let format = if vinfo.format == GRAY_FORMAT { GRAY_FORMAT } else { PAL8_FORMAT };
275 let outinfo = NAVideoInfo::new(vinfo.width, vinfo.height, false, format);
276 let mut ofmt = *encinfo;
277 ofmt.format = NACodecTypeInfo::Video(outinfo);
282 fn get_capabilities(&self) -> u64 { ENC_CAPS_SKIPFRAME }
283 fn init(&mut self, stream_id: u32, encinfo: EncodeParameters) -> EncoderResult<NAStreamRef> {
284 match encinfo.format {
285 NACodecTypeInfo::None => Err(EncoderError::FormatError),
286 NACodecTypeInfo::Audio(_) => Err(EncoderError::FormatError),
287 NACodecTypeInfo::Video(vinfo) => {
288 if vinfo.width > 65535 || vinfo.height > 65535 {
289 return Err(EncoderError::FormatError);
291 if vinfo.format != PAL8_FORMAT && vinfo.format != GRAY_FORMAT {
292 return Err(EncoderError::FormatError);
294 self.width = vinfo.width;
295 self.height = vinfo.height;
296 self.grayscale = vinfo.format == GRAY_FORMAT;
298 let edata = self.tr_idx.map(|val| vec![val]);
300 let out_info = NAVideoInfo::new(vinfo.width, vinfo.height, false, PAL8_FORMAT);
301 let info = NACodecInfo::new("gif", NACodecTypeInfo::Video(out_info), edata);
302 let mut stream = NAStream::new(StreamType::Video, stream_id, info, encinfo.tb_num, encinfo.tb_den, 0);
303 stream.set_num(stream_id as usize);
304 let stream = stream.into_ref();
306 self.stream = Some(stream.clone());
308 self.cur_frm = vec![0; vinfo.width * vinfo.height];
309 self.prev_frm = vec![0; vinfo.width * vinfo.height];
310 self.tmp_buf.clear();
311 self.tmp_buf.reserve(vinfo.width * vinfo.height);
319 fn encode(&mut self, frm: &NAFrame) -> EncoderResult<()> {
320 let mut dbuf = Vec::with_capacity(4);
321 let mut gw = GrowableMemoryWriter::new_write(&mut dbuf);
322 let mut bw = ByteWriter::new(&mut gw);
324 self.tmp_buf.clear();
326 match frm.get_buffer() {
327 NABufferType::Video(ref buf) => {
328 let src = buf.get_data();
329 let stride = buf.get_stride(0);
330 let src = &src[buf.get_offset(0)..];
332 for (dline, sline) in self.cur_frm.chunks_exact_mut(self.width)
333 .zip(src.chunks_exact(stride)) {
334 dline.copy_from_slice(&sline[..self.width]);
337 let cur_pal = &src[buf.get_offset(1)..][..768];
340 self.pal.copy_from_slice(cur_pal);
342 for (i, pal) in self.pal.chunks_exact_mut(3).enumerate() {
350 let mut pal_changed = false;
351 if !self.first && !self.grayscale {
352 let mut used = [false; 256];
353 for &b in self.cur_frm.iter() {
354 used[usize::from(b)] = true;
356 for (&used, (pal1, pal2)) in used.iter()
357 .zip(self.pal.chunks_exact(3).zip(cur_pal.chunks_exact(3))) {
358 if used && (pal1 != pal2) {
366 bw.write_byte(0x2C)?; // image descriptor
367 bw.write_u16le(0)?; // left
368 bw.write_u16le(0)?; // top
369 bw.write_u16le(self.width as u16)?;
370 bw.write_u16le(self.height as u16)?;
371 bw.write_byte(0)?; // flags
372 self.lzw.compress(&mut bw, &self.cur_frm)?;
375 for (y, (line1, line2)) in self.cur_frm.chunks_exact(self.width)
376 .zip(self.prev_frm.chunks_exact(self.width)).enumerate() {
383 if top != self.height - 1 {
384 let mut bot = self.height;
385 for (y, (line1, line2)) in self.cur_frm.chunks_exact(self.width)
386 .zip(self.prev_frm.chunks_exact(self.width)).enumerate().rev() {
393 let mut left = self.width - 1;
395 for (line1, line2) in self.cur_frm.chunks_exact(self.width)
396 .zip(self.prev_frm.chunks_exact(self.width))
397 .skip(top).take(bot - top) {
400 for (x, (&p1, &p2)) in line1.iter().zip(line2.iter()).enumerate() {
407 left = left.min(cur_l);
409 if right < self.width {
410 let mut cur_r = self.width;
411 for (x, (&p1, &p2)) in line1.iter().zip(line2.iter())
419 right = right.max(cur_r);
422 self.tmp_buf.clear();
423 let use_transparency = self.p_trans && self.tr_idx.is_some();
424 let full_frame = right == 0 && top == 0 && left == self.width && bot == self.height;
426 let pic = match (use_transparency, full_frame) {
428 let tr_idx = self.tr_idx.unwrap_or(0);
429 for (cline, pline) in self.cur_frm.chunks_exact(self.width)
430 .zip(self.prev_frm.chunks_exact(self.width))
431 .skip(top).take(bot - top) {
432 for (&cpix, &ppix) in cline[left..right].iter()
433 .zip(pline[left..right].iter()) {
434 self.tmp_buf.push(if cpix == ppix { tr_idx } else { cpix });
443 for line in self.cur_frm.chunks_exact(self.width)
444 .skip(top).take(bot - top) {
445 self.tmp_buf.extend_from_slice(&line[left..right]);
451 bw.write_byte(0x2C)?; // image descriptor
452 bw.write_u16le(left as u16)?;
453 bw.write_u16le(top as u16)?;
454 bw.write_u16le((right - left) as u16)?;
455 bw.write_u16le((bot - top) as u16)?;
457 bw.write_byte(0)?; // flags
459 let maxclr = pic.iter().fold(0u8, |acc, &a| acc.max(a));
460 let clr_bits = if maxclr > 128 {
464 while (1 << bits) < maxclr {
469 bw.write_byte(0x80 | (clr_bits - 1))?;
470 bw.write_buf(&cur_pal[..(3 << clr_bits)])?;
472 self.lzw.compress(&mut bw, pic)?;
474 self.write_dummy_frame(&mut bw)?;
478 NABufferType::None if !self.first => {
479 self.write_dummy_frame(&mut bw)?;
481 _ => return Err(EncoderError::InvalidParameters),
484 self.pkt = Some(NAPacket::new(self.stream.clone().unwrap(), frm.ts, self.first, dbuf));
488 if let NABufferType::Video(ref buf) = frm.get_buffer() {
489 let paloff = buf.get_offset(1);
490 let data = buf.get_data();
491 let mut pal = [0; 1024];
492 let srcpal = &data[paloff..][..768];
493 for (dclr, sclr) in pal.chunks_exact_mut(4).zip(srcpal.chunks_exact(3)) {
494 dclr[..3].copy_from_slice(sclr);
496 if let Some(ref mut pkt) = &mut self.pkt {
497 pkt.side_data.push(NASideData::Palette(true, Arc::new(pal)));
501 let mut pal = [0; 1024];
502 for (i, quad) in pal.chunks_exact_mut(4).enumerate() {
507 if let Some(ref mut pkt) = &mut self.pkt {
508 pkt.side_data.push(NASideData::Palette(true, Arc::new(pal)));
512 std::mem::swap(&mut self.cur_frm, &mut self.prev_frm);
515 fn get_packet(&mut self) -> EncoderResult<Option<NAPacket>> {
517 std::mem::swap(&mut self.pkt, &mut npkt);
520 fn flush(&mut self) -> EncoderResult<()> {
525 const ENCODER_OPTS: &[NAOptionDefinition] = &[
527 name: "compr", description: "Compression level",
528 opt_type: NAOptionDefinitionType::String(Some(&["none", "fast", "best"])) },
530 name: "inter_transparent", description: "Code changed regions with transparency",
531 opt_type: NAOptionDefinitionType::Bool },
533 name: "transparent_idx", description: "Palette index to use for transparency (on inter frames too if requested)",
534 opt_type: NAOptionDefinitionType::Int(Some(-1), Some(255)) },
537 impl NAOptionHandler for GIFEncoder {
538 fn get_supported_options(&self) -> &[NAOptionDefinition] { ENCODER_OPTS }
539 fn set_options(&mut self, options: &[NAOption]) {
540 for option in options.iter() {
541 for opt_def in ENCODER_OPTS.iter() {
542 if opt_def.check(option).is_ok() {
545 if let NAValue::String(ref strval) = option.value {
546 match strval.as_str() {
547 "none" => self.lzw.level = CompressionLevel::None,
548 "fast" => self.lzw.level = CompressionLevel::Fast,
549 "best" => self.lzw.level = CompressionLevel::Best,
554 "inter_transparent" => {
555 if let NAValue::Bool(bval) = option.value {
559 "transparent_idx" => {
560 if let NAValue::Int(ival) = option.value {
561 self.tr_idx = if ival >= 0 { Some(ival as u8) } else { None };
570 fn query_option_value(&self, name: &str) -> Option<NAValue> {
572 "compr" => Some(NAValue::String(self.lzw.level.to_string())),
573 "inter_transparent" => Some(NAValue::Bool(self.p_trans)),
574 "transparent_idx" => Some(NAValue::Int(self.tr_idx.map_or(-1i64, i64::from))),
580 pub fn get_encoder() -> Box<dyn NAEncoder + Send> {
581 Box::new(GIFEncoder::new())
586 use nihav_core::codecs::*;
587 use nihav_core::demuxers::*;
588 use nihav_core::muxers::*;
590 use nihav_codec_support::test::enc_video::*;
592 // sample: https://samples.mplayerhq.hu/V-codecs/Uncompressed/8bpp.avi
593 fn test_gif_encoder_single(out_name: &'static str, enc_options: &[NAOption], hash: &[u32; 4]) {
594 let mut dmx_reg = RegisteredDemuxers::new();
595 generic_register_all_demuxers(&mut dmx_reg);
596 let mut dec_reg = RegisteredDecoders::new();
597 generic_register_all_decoders(&mut dec_reg);
598 let mut mux_reg = RegisteredMuxers::new();
599 generic_register_all_muxers(&mut mux_reg);
600 let mut enc_reg = RegisteredEncoders::new();
601 generic_register_all_encoders(&mut enc_reg);
603 let dec_config = DecoderTestParams {
605 in_name: "assets/Misc/8bpp.avi",
606 stream_type: StreamType::Video,
610 let enc_config = EncoderTestParams {
616 let dst_vinfo = NAVideoInfo {
623 let enc_params = EncodeParameters {
624 format: NACodecTypeInfo::Video(dst_vinfo),
631 //test_encoding_to_file(&dec_config, &enc_config, enc_params, enc_options);
632 test_encoding_md5(&dec_config, &enc_config, enc_params, enc_options, hash);
634 // sample: https://samples.mplayerhq.hu/image-samples/GIF/3D.gif
635 fn test_gif_anim(out_name: &'static str, enc_options: &[NAOption], hash: &[u32; 4]) {
636 let mut dmx_reg = RegisteredDemuxers::new();
637 generic_register_all_demuxers(&mut dmx_reg);
638 let mut dec_reg = RegisteredDecoders::new();
639 generic_register_all_decoders(&mut dec_reg);
640 let mut mux_reg = RegisteredMuxers::new();
641 generic_register_all_muxers(&mut mux_reg);
642 let mut enc_reg = RegisteredEncoders::new();
643 generic_register_all_encoders(&mut enc_reg);
645 let dec_config = DecoderTestParams {
647 in_name: "assets/Misc/3D.gif",
648 stream_type: StreamType::Video,
652 let enc_config = EncoderTestParams {
658 let dst_vinfo = NAVideoInfo {
665 let enc_params = EncodeParameters {
666 format: NACodecTypeInfo::Video(dst_vinfo),
673 //test_encoding_to_file(&dec_config, &enc_config, enc_params, enc_options);
674 test_encoding_md5(&dec_config, &enc_config, enc_params, enc_options, hash);
677 fn test_gif_single_none() {
679 NAOption { name: "compr", value: NAValue::String("none".to_string()) },
681 test_gif_encoder_single("none.gif", enc_options, &[0x32900cff, 0xef979bb0, 0x2d0355e8, 0x424bddee]);
684 fn test_gif_single_fast() {
686 NAOption { name: "compr", value: NAValue::String("fast".to_string()) },
688 test_gif_encoder_single("fast.gif", enc_options, &[0x9644f682, 0x497593cd, 0xdabb483d, 0x8fce63f4]);
691 fn test_gif_single_best() {
693 NAOption { name: "compr", value: NAValue::String("best".to_string()) },
695 test_gif_encoder_single("best.gif", enc_options, &[0x9644f682, 0x497593cd, 0xdabb483d, 0x8fce63f4]);
698 fn test_gif_anim_opaque() {
700 NAOption { name: "compr", value: NAValue::String("fast".to_string()) },
702 test_gif_anim("anim-opaque.gif", enc_options, &[0x58489e31, 0x1721d75e, 0xaebf93f2, 0x3fea9c6e]);
705 fn test_gif_anim_transparent() {
707 NAOption { name: "compr", value: NAValue::String("fast".to_string()) },
708 NAOption { name: "inter_transparent", value: NAValue::Bool(true) },
709 NAOption { name: "transparent_idx", value: NAValue::Int(0x7F) },
711 test_gif_anim("anim-transp.gif", enc_options, &[0x62df6232, 0x0c334457, 0x73738404, 0xa8829dcc]);