1 use nihav_core::codecs::*;
2 use nihav_core::io::byteio::*;
3 use nihav_core::io::bitwriter::*;
5 #[derive(Clone,Copy,Default,PartialEq)]
6 enum CompressionLevel {
13 impl std::string::ToString for CompressionLevel {
14 fn to_string(&self) -> String {
16 CompressionLevel::None => "none".to_string(),
17 CompressionLevel::Fast => "fast".to_string(),
18 CompressionLevel::Best => "best".to_string(),
23 const NO_CODE: u16 = 0;
25 struct LZWDictionary {
31 trie: Vec<[u16; 257]>,
37 trie: Vec::with_capacity(4096),
45 fn init(&mut self, bits: u8) {
46 self.cur_size = (1 << bits) + 2;
47 self.bit_len = bits + 1;
48 self.clear_code = 1 << bits;
49 self.end_code = self.clear_code + 1;
50 self.orig_len = self.bit_len;
53 for _ in 0..self.cur_size {
54 self.trie.push([NO_CODE; 257]);
56 for (idx, nodes) in self.trie.iter_mut().enumerate() {
57 nodes[256] = idx as u16;
60 fn find(&self, src: &[u8]) -> (u16, usize, usize) {
61 let mut idx = usize::from(src[0]);
63 for (pos, &next) in src.iter().enumerate().skip(1) {
64 let next = usize::from(next);
65 if self.trie[idx][next] != NO_CODE {
66 idx = usize::from(self.trie[idx][next]);
68 return (self.trie[idx][256], pos, idx);
72 (self.trie[idx][256], last_len + 1, idx)
74 fn add(&mut self, lastidx: usize, next: u8) {
75 if self.cur_size >= (1 << 12) {
78 let next = usize::from(next);
79 if self.trie[lastidx][next] == NO_CODE {
80 let newnode = self.trie.len();
81 self.trie.push([NO_CODE; 257]);
82 self.trie[newnode][256] = self.cur_size as u16;
83 self.trie[lastidx][next] = newnode as u16;
85 if (self.cur_size & (self.cur_size - 1)) == 0 && self.bit_len < 12 {
91 self.bit_len = self.orig_len;
92 self.cur_size = usize::from(self.end_code) + 1;
93 self.trie.truncate(self.cur_size);
94 for nodes in self.trie.iter_mut() {
95 for el in nodes[..256].iter_mut() {
104 level: CompressionLevel,
111 dict: LZWDictionary::new(),
112 level: CompressionLevel::default(),
116 fn compress(&mut self, writer: &mut ByteWriter, src: &[u8]) -> EncoderResult<()> {
117 let clr_bits: u8 = if self.level != CompressionLevel::None {
118 let maxclr = u16::from(src.iter().fold(0u8, |acc, &a| acc.max(a))) + 1;
120 while (1 << bits) < maxclr {
126 self.dict.init(clr_bits);
129 let mut tbuf = Vec::new();
130 std::mem::swap(&mut tbuf, &mut self.tmp);
131 let mut bw = BitWriter::new(tbuf, BitWriterMode::LE);
133 bw.write(u32::from(self.dict.clear_code), self.dict.bit_len);
136 CompressionLevel::None => {
137 let sym_limit = 1 << (clr_bits + 1);
138 for &b in src.iter() {
139 if self.dict.cur_size >= sym_limit {
140 bw.write(u32::from(self.dict.clear_code), self.dict.bit_len);
143 bw.write(u32::from(b), self.dict.bit_len);
144 self.dict.add(usize::from(b), 0);
147 CompressionLevel::Fast => {
149 while pos < src.len() {
150 let (idx, len, trieidx) = self.dict.find(&src[pos..]);
151 bw.write(u32::from(idx), self.dict.bit_len);
154 self.dict.add(trieidx, src[pos]);
156 if self.dict.cur_size == 4096 {
157 bw.write(u32::from(self.dict.clear_code), self.dict.bit_len);
162 CompressionLevel::Best => {
164 let mut hist = [0; 16];
168 while pos < src.len() {
169 let (idx, len, trieidx) = self.dict.find(&src[pos..]);
170 bw.write(u32::from(idx), self.dict.bit_len);
172 if pos >= src.len() {
175 self.dict.add(trieidx, src[pos]);
177 avg1 -= hist[(hpos + 1) & 0xF];
179 if self.dict.cur_size == 4096 && (avg1 < avg - avg / 8) {
180 bw.write(u32::from(self.dict.clear_code), self.dict.bit_len);
184 hpos = (hpos + 1) & 0xF;
190 bw.write(u32::from(self.dict.end_code), self.dict.bit_len);
192 std::mem::swap(&mut tbuf, &mut self.tmp);
194 writer.write_byte(clr_bits)?;
195 for chunk in self.tmp.chunks(255) {
196 writer.write_byte(chunk.len() as u8)?;
197 writer.write_buf(chunk)?;
199 writer.write_byte(0x00)?; // data end marker
205 stream: Option<NAStreamRef>,
210 pkt: Option<NAPacket>,
225 prev_frm: Vec::new(),
231 lzw: LZWEncoder::new(),
236 fn write_dummy_frame(&mut self, bw: &mut ByteWriter) -> EncoderResult<()> {
237 let mut pix = [self.cur_frm[0]];
238 if let (true, Some(tr_idx)) = (self.p_trans, self.tr_idx) {
244 // 1x1 image descriptor
245 bw.write_buf(&[0x2C, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x01, 0x00, 0x00])?;
246 self.lzw.compress(bw, &pix)?;
251 impl NAEncoder for GIFEncoder {
252 fn negotiate_format(&self, encinfo: &EncodeParameters) -> EncoderResult<EncodeParameters> {
253 match encinfo.format {
254 NACodecTypeInfo::None => {
255 Ok(EncodeParameters {
256 format: NACodecTypeInfo::Video(NAVideoInfo::new(0, 0, true, YUV420_FORMAT)),
260 NACodecTypeInfo::Audio(_) => Err(EncoderError::FormatError),
261 NACodecTypeInfo::Video(vinfo) => {
262 let outinfo = NAVideoInfo::new(vinfo.width, vinfo.height, false, PAL8_FORMAT);
263 let mut ofmt = *encinfo;
264 ofmt.format = NACodecTypeInfo::Video(outinfo);
269 fn get_capabilities(&self) -> u64 { ENC_CAPS_SKIPFRAME }
270 fn init(&mut self, stream_id: u32, encinfo: EncodeParameters) -> EncoderResult<NAStreamRef> {
271 match encinfo.format {
272 NACodecTypeInfo::None => Err(EncoderError::FormatError),
273 NACodecTypeInfo::Audio(_) => Err(EncoderError::FormatError),
274 NACodecTypeInfo::Video(vinfo) => {
275 if vinfo.width > 65535 || vinfo.height > 65535 {
276 return Err(EncoderError::FormatError);
278 self.width = vinfo.width;
279 self.height = vinfo.height;
281 let edata = self.tr_idx.map(|val| vec![val]);
283 let out_info = NAVideoInfo::new(vinfo.width, vinfo.height, false, PAL8_FORMAT);
284 let info = NACodecInfo::new("gif", NACodecTypeInfo::Video(out_info), edata);
285 let mut stream = NAStream::new(StreamType::Video, stream_id, info, encinfo.tb_num, encinfo.tb_den, 0);
286 stream.set_num(stream_id as usize);
287 let stream = stream.into_ref();
289 self.stream = Some(stream.clone());
291 self.cur_frm = vec![0; vinfo.width * vinfo.height];
292 self.prev_frm = vec![0; vinfo.width * vinfo.height];
293 self.tmp_buf.clear();
294 self.tmp_buf.reserve(vinfo.width * vinfo.height);
302 fn encode(&mut self, frm: &NAFrame) -> EncoderResult<()> {
303 let mut dbuf = Vec::with_capacity(4);
304 let mut gw = GrowableMemoryWriter::new_write(&mut dbuf);
305 let mut bw = ByteWriter::new(&mut gw);
307 self.tmp_buf.clear();
309 match frm.get_buffer() {
310 NABufferType::Video(ref buf) => {
311 let src = buf.get_data();
312 let stride = buf.get_stride(0);
313 let src = &src[buf.get_offset(0)..];
315 for (dline, sline) in self.cur_frm.chunks_exact_mut(self.width)
316 .zip(src.chunks_exact(stride)) {
317 dline.copy_from_slice(&sline[..self.width]);
320 let cur_pal = &src[buf.get_offset(1)..][..768];
322 self.pal.copy_from_slice(cur_pal);
325 let mut pal_changed = false;
327 let mut used = [false; 256];
328 for &b in self.cur_frm.iter() {
329 used[usize::from(b)] = true;
331 for (&used, (pal1, pal2)) in used.iter()
332 .zip(self.pal.chunks_exact(3).zip(cur_pal.chunks_exact(3))) {
333 if used && (pal1 != pal2) {
341 bw.write_byte(0x2C)?; // image descriptor
342 bw.write_u16le(0)?; // left
343 bw.write_u16le(0)?; // top
344 bw.write_u16le(self.width as u16)?;
345 bw.write_u16le(self.height as u16)?;
346 bw.write_byte(0)?; // flags
347 self.lzw.compress(&mut bw, &self.cur_frm)?;
350 for (y, (line1, line2)) in self.cur_frm.chunks_exact(self.width)
351 .zip(self.prev_frm.chunks_exact(self.width)).enumerate() {
358 if top != self.height - 1 {
359 let mut bot = self.height;
360 for (y, (line1, line2)) in self.cur_frm.chunks_exact(self.width)
361 .zip(self.prev_frm.chunks_exact(self.width)).enumerate().rev() {
368 let mut left = self.width - 1;
370 for (line1, line2) in self.cur_frm.chunks_exact(self.width)
371 .zip(self.prev_frm.chunks_exact(self.width))
372 .skip(top).take(bot - top) {
375 for (x, (&p1, &p2)) in line1.iter().zip(line2.iter()).enumerate() {
382 left = left.min(cur_l);
384 if right < self.width {
385 let mut cur_r = self.width;
386 for (x, (&p1, &p2)) in line1.iter().zip(line2.iter())
394 right = right.max(cur_r);
397 self.tmp_buf.clear();
398 let use_transparency = self.p_trans && self.tr_idx.is_some();
399 let full_frame = right == 0 && top == 0 && left == self.width && bot == self.height;
401 let pic = match (use_transparency, full_frame) {
403 let tr_idx = self.tr_idx.unwrap_or(0);
404 for (cline, pline) in self.cur_frm.chunks_exact(self.width)
405 .zip(self.prev_frm.chunks_exact(self.width))
406 .skip(top).take(bot - top) {
407 for (&cpix, &ppix) in cline[left..right].iter()
408 .zip(pline[left..right].iter()) {
409 self.tmp_buf.push(if cpix == ppix { tr_idx } else { cpix });
418 for line in self.cur_frm.chunks_exact(self.width)
419 .skip(top).take(bot - top) {
420 self.tmp_buf.extend_from_slice(&line[left..right]);
426 bw.write_byte(0x2C)?; // image descriptor
427 bw.write_u16le(left as u16)?;
428 bw.write_u16le(top as u16)?;
429 bw.write_u16le((right - left) as u16)?;
430 bw.write_u16le((bot - top) as u16)?;
432 bw.write_byte(0)?; // flags
434 let maxclr = pic.iter().fold(0u8, |acc, &a| acc.max(a));
435 let clr_bits = if maxclr > 128 {
439 while (1 << bits) < maxclr {
444 bw.write_byte(0x80 | (clr_bits - 1))?;
445 bw.write_buf(&cur_pal[..(3 << clr_bits)])?;
447 self.lzw.compress(&mut bw, pic)?;
449 self.write_dummy_frame(&mut bw)?;
453 NABufferType::None if !self.first => {
454 self.write_dummy_frame(&mut bw)?;
456 _ => return Err(EncoderError::InvalidParameters),
459 self.pkt = Some(NAPacket::new(self.stream.clone().unwrap(), frm.ts, self.first, dbuf));
462 if let NABufferType::Video(ref buf) = frm.get_buffer() {
463 let paloff = buf.get_offset(1);
464 let data = buf.get_data();
465 let mut pal = [0; 1024];
466 let srcpal = &data[paloff..][..768];
467 for (dclr, sclr) in pal.chunks_exact_mut(4).zip(srcpal.chunks_exact(3)) {
468 dclr[..3].copy_from_slice(sclr);
470 if let Some(ref mut pkt) = &mut self.pkt {
471 pkt.side_data.push(NASideData::Palette(true, Arc::new(pal)));
475 std::mem::swap(&mut self.cur_frm, &mut self.prev_frm);
478 fn get_packet(&mut self) -> EncoderResult<Option<NAPacket>> {
480 std::mem::swap(&mut self.pkt, &mut npkt);
483 fn flush(&mut self) -> EncoderResult<()> {
488 const ENCODER_OPTS: &[NAOptionDefinition] = &[
490 name: "compr", description: "Compression level",
491 opt_type: NAOptionDefinitionType::String(Some(&["none", "fast", "best"])) },
493 name: "inter_transparent", description: "Code changed regions with transparency",
494 opt_type: NAOptionDefinitionType::Bool },
496 name: "transparent_idx", description: "Palette index to use for transparency (on inter frames too if requested)",
497 opt_type: NAOptionDefinitionType::Int(Some(-1), Some(255)) },
500 impl NAOptionHandler for GIFEncoder {
501 fn get_supported_options(&self) -> &[NAOptionDefinition] { ENCODER_OPTS }
502 fn set_options(&mut self, options: &[NAOption]) {
503 for option in options.iter() {
504 for opt_def in ENCODER_OPTS.iter() {
505 if opt_def.check(option).is_ok() {
508 if let NAValue::String(ref strval) = option.value {
509 match strval.as_str() {
510 "none" => self.lzw.level = CompressionLevel::None,
511 "fast" => self.lzw.level = CompressionLevel::Fast,
512 "best" => self.lzw.level = CompressionLevel::Best,
517 "inter_transparent" => {
518 if let NAValue::Bool(bval) = option.value {
522 "transparent_idx" => {
523 if let NAValue::Int(ival) = option.value {
524 self.tr_idx = if ival >= 0 { Some(ival as u8) } else { None };
533 fn query_option_value(&self, name: &str) -> Option<NAValue> {
535 "compr" => Some(NAValue::String(self.lzw.level.to_string())),
536 "inter_transparent" => Some(NAValue::Bool(self.p_trans)),
537 "transparent_idx" => Some(NAValue::Int(self.tr_idx.map_or(-1i64, i64::from))),
543 pub fn get_encoder() -> Box<dyn NAEncoder + Send> {
544 Box::new(GIFEncoder::new())
549 use nihav_core::codecs::*;
550 use nihav_core::demuxers::*;
551 use nihav_core::muxers::*;
553 use nihav_codec_support::test::enc_video::*;
555 // sample: https://samples.mplayerhq.hu/V-codecs/Uncompressed/8bpp.avi
556 fn test_gif_encoder_single(out_name: &'static str, enc_options: &[NAOption], hash: &[u32; 4]) {
557 let mut dmx_reg = RegisteredDemuxers::new();
558 generic_register_all_demuxers(&mut dmx_reg);
559 let mut dec_reg = RegisteredDecoders::new();
560 generic_register_all_decoders(&mut dec_reg);
561 let mut mux_reg = RegisteredMuxers::new();
562 generic_register_all_muxers(&mut mux_reg);
563 let mut enc_reg = RegisteredEncoders::new();
564 generic_register_all_encoders(&mut enc_reg);
566 let dec_config = DecoderTestParams {
568 in_name: "assets/Misc/8bpp.avi",
569 stream_type: StreamType::Video,
573 let enc_config = EncoderTestParams {
579 let dst_vinfo = NAVideoInfo {
586 let enc_params = EncodeParameters {
587 format: NACodecTypeInfo::Video(dst_vinfo),
594 //test_encoding_to_file(&dec_config, &enc_config, enc_params, enc_options);
595 test_encoding_md5(&dec_config, &enc_config, enc_params, enc_options, hash);
597 // sample: https://samples.mplayerhq.hu/image-samples/GIF/3D.gif
598 fn test_gif_anim(out_name: &'static str, enc_options: &[NAOption], hash: &[u32; 4]) {
599 let mut dmx_reg = RegisteredDemuxers::new();
600 generic_register_all_demuxers(&mut dmx_reg);
601 let mut dec_reg = RegisteredDecoders::new();
602 generic_register_all_decoders(&mut dec_reg);
603 let mut mux_reg = RegisteredMuxers::new();
604 generic_register_all_muxers(&mut mux_reg);
605 let mut enc_reg = RegisteredEncoders::new();
606 generic_register_all_encoders(&mut enc_reg);
608 let dec_config = DecoderTestParams {
610 in_name: "assets/Misc/3D.gif",
611 stream_type: StreamType::Video,
615 let enc_config = EncoderTestParams {
621 let dst_vinfo = NAVideoInfo {
628 let enc_params = EncodeParameters {
629 format: NACodecTypeInfo::Video(dst_vinfo),
636 //test_encoding_to_file(&dec_config, &enc_config, enc_params, enc_options);
637 test_encoding_md5(&dec_config, &enc_config, enc_params, enc_options, hash);
640 fn test_gif_single_none() {
642 NAOption { name: "compr", value: NAValue::String("none".to_string()) },
644 test_gif_encoder_single("none.gif", enc_options, &[0x32900cff, 0xef979bb0, 0x2d0355e8, 0x424bddee]);
647 fn test_gif_single_fast() {
649 NAOption { name: "compr", value: NAValue::String("fast".to_string()) },
651 test_gif_encoder_single("fast.gif", enc_options, &[0x9644f682, 0x497593cd, 0xdabb483d, 0x8fce63f4]);
654 fn test_gif_single_best() {
656 NAOption { name: "compr", value: NAValue::String("best".to_string()) },
658 test_gif_encoder_single("best.gif", enc_options, &[0x9644f682, 0x497593cd, 0xdabb483d, 0x8fce63f4]);
661 fn test_gif_anim_opaque() {
663 NAOption { name: "compr", value: NAValue::String("fast".to_string()) },
665 test_gif_anim("anim-opaque.gif", enc_options, &[0x58489e31, 0x1721d75e, 0xaebf93f2, 0x3fea9c6e]);
668 fn test_gif_anim_transparent() {
670 NAOption { name: "compr", value: NAValue::String("fast".to_string()) },
671 NAOption { name: "inter_transparent", value: NAValue::Bool(true) },
672 NAOption { name: "transparent_idx", value: NAValue::Int(0x7F) },
674 test_gif_anim("anim-transp.gif", enc_options, &[0x62df6232, 0x0c334457, 0x73738404, 0xa8829dcc]);