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 for &b in src.iter() {
138 bw.write(u32::from(b), self.dict.bit_len);
139 self.dict.add(usize::from(b), 0);
142 CompressionLevel::Fast => {
144 while pos < src.len() {
145 let (idx, len, trieidx) = self.dict.find(&src[pos..]);
146 bw.write(u32::from(idx), self.dict.bit_len);
149 self.dict.add(trieidx, src[pos]);
151 if self.dict.cur_size == 4096 {
152 bw.write(u32::from(self.dict.clear_code), self.dict.bit_len);
157 CompressionLevel::Best => {
159 let mut hist = [0; 16];
163 while pos < src.len() {
164 let (idx, len, trieidx) = self.dict.find(&src[pos..]);
165 bw.write(u32::from(idx), self.dict.bit_len);
167 if pos >= src.len() {
170 self.dict.add(trieidx, src[pos]);
172 avg1 -= hist[(hpos + 1) & 0xF];
174 if self.dict.cur_size == 4096 && (avg1 < avg - avg / 8) {
175 bw.write(u32::from(self.dict.clear_code), self.dict.bit_len);
179 hpos = (hpos + 1) & 0xF;
185 bw.write(u32::from(self.dict.end_code), self.dict.bit_len);
187 std::mem::swap(&mut tbuf, &mut self.tmp);
189 writer.write_byte(clr_bits)?;
190 for chunk in self.tmp.chunks(255) {
191 writer.write_byte(chunk.len() as u8)?;
192 writer.write_buf(chunk)?;
194 writer.write_byte(0x00)?; // data end marker
200 stream: Option<NAStreamRef>,
205 pkt: Option<NAPacket>,
220 prev_frm: Vec::new(),
226 lzw: LZWEncoder::new(),
231 fn write_dummy_frame(&mut self, bw: &mut ByteWriter) -> EncoderResult<()> {
232 let mut pix = [self.cur_frm[0]];
233 if let (true, Some(tr_idx)) = (self.p_trans, self.tr_idx) {
239 // 1x1 image descriptor
240 bw.write_buf(&[0x2C, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x01, 0x00, 0x00])?;
241 self.lzw.compress(bw, &pix)?;
246 impl NAEncoder for GIFEncoder {
247 fn negotiate_format(&self, encinfo: &EncodeParameters) -> EncoderResult<EncodeParameters> {
248 match encinfo.format {
249 NACodecTypeInfo::None => {
250 Ok(EncodeParameters {
251 format: NACodecTypeInfo::Video(NAVideoInfo::new(0, 0, true, YUV420_FORMAT)),
255 NACodecTypeInfo::Audio(_) => Err(EncoderError::FormatError),
256 NACodecTypeInfo::Video(vinfo) => {
257 let outinfo = NAVideoInfo::new(vinfo.width, vinfo.height, false, PAL8_FORMAT);
258 let mut ofmt = *encinfo;
259 ofmt.format = NACodecTypeInfo::Video(outinfo);
264 fn get_capabilities(&self) -> u64 { ENC_CAPS_SKIPFRAME }
265 fn init(&mut self, stream_id: u32, encinfo: EncodeParameters) -> EncoderResult<NAStreamRef> {
266 match encinfo.format {
267 NACodecTypeInfo::None => Err(EncoderError::FormatError),
268 NACodecTypeInfo::Audio(_) => Err(EncoderError::FormatError),
269 NACodecTypeInfo::Video(vinfo) => {
270 if vinfo.width > 65535 || vinfo.height > 65535 {
271 return Err(EncoderError::FormatError);
273 self.width = vinfo.width;
274 self.height = vinfo.height;
276 let edata = self.tr_idx.map(|val| vec![val]);
278 let out_info = NAVideoInfo::new(vinfo.width, vinfo.height, false, PAL8_FORMAT);
279 let info = NACodecInfo::new("gif", NACodecTypeInfo::Video(out_info), edata);
280 let mut stream = NAStream::new(StreamType::Video, stream_id, info, encinfo.tb_num, encinfo.tb_den, 0);
281 stream.set_num(stream_id as usize);
282 let stream = stream.into_ref();
284 self.stream = Some(stream.clone());
286 self.cur_frm = vec![0; vinfo.width * vinfo.height];
287 self.prev_frm = vec![0; vinfo.width * vinfo.height];
288 self.tmp_buf.clear();
289 self.tmp_buf.reserve(vinfo.width * vinfo.height);
297 fn encode(&mut self, frm: &NAFrame) -> EncoderResult<()> {
298 let mut dbuf = Vec::with_capacity(4);
299 let mut gw = GrowableMemoryWriter::new_write(&mut dbuf);
300 let mut bw = ByteWriter::new(&mut gw);
302 self.tmp_buf.clear();
304 match frm.get_buffer() {
305 NABufferType::Video(ref buf) => {
306 let src = buf.get_data();
307 let stride = buf.get_stride(0);
308 let src = &src[buf.get_offset(0)..];
310 for (dline, sline) in self.cur_frm.chunks_exact_mut(self.width)
311 .zip(src.chunks_exact(stride)) {
312 dline.copy_from_slice(&sline[..self.width]);
315 let cur_pal = &src[buf.get_offset(1)..][..768];
317 self.pal.copy_from_slice(cur_pal);
320 let mut pal_changed = false;
322 let mut used = [false; 256];
323 for &b in self.cur_frm.iter() {
324 used[usize::from(b)] = true;
326 for (&used, (pal1, pal2)) in used.iter()
327 .zip(self.pal.chunks_exact(3).zip(cur_pal.chunks_exact(3))) {
328 if used && (pal1 != pal2) {
336 bw.write_byte(0x2C)?; // image descriptor
337 bw.write_u16le(0)?; // left
338 bw.write_u16le(0)?; // top
339 bw.write_u16le(self.width as u16)?;
340 bw.write_u16le(self.height as u16)?;
341 bw.write_byte(0)?; // flags
342 self.lzw.compress(&mut bw, &self.cur_frm)?;
345 for (y, (line1, line2)) in self.cur_frm.chunks_exact(self.width)
346 .zip(self.prev_frm.chunks_exact(self.width)).enumerate() {
353 if top != self.height - 1 {
354 let mut bot = self.height;
355 for (y, (line1, line2)) in self.cur_frm.chunks_exact(self.width)
356 .zip(self.prev_frm.chunks_exact(self.width)).enumerate().rev() {
363 let mut left = self.width - 1;
365 for (line1, line2) in self.cur_frm.chunks_exact(self.width)
366 .zip(self.prev_frm.chunks_exact(self.width))
367 .skip(top).take(bot - top) {
370 for (x, (&p1, &p2)) in line1.iter().zip(line2.iter()).enumerate() {
377 left = left.min(cur_l);
379 if right < self.width {
380 let mut cur_r = self.width;
381 for (x, (&p1, &p2)) in line1.iter().zip(line2.iter())
389 right = right.max(cur_r);
392 self.tmp_buf.clear();
393 let use_transparency = self.p_trans && self.tr_idx.is_some();
394 let full_frame = right == 0 && top == 0 && left == self.width && bot == self.height;
396 let pic = match (use_transparency, full_frame) {
398 let tr_idx = self.tr_idx.unwrap_or(0);
399 for (cline, pline) in self.cur_frm.chunks_exact(self.width)
400 .zip(self.prev_frm.chunks_exact(self.width))
401 .skip(top).take(bot - top) {
402 for (&cpix, &ppix) in cline[left..right].iter()
403 .zip(pline[left..right].iter()) {
404 self.tmp_buf.push(if cpix == ppix { tr_idx } else { cpix });
413 for line in self.cur_frm.chunks_exact(self.width)
414 .skip(top).take(bot - top) {
415 self.tmp_buf.extend_from_slice(&line[left..right]);
421 bw.write_byte(0x2C)?; // image descriptor
422 bw.write_u16le(left as u16)?;
423 bw.write_u16le(top as u16)?;
424 bw.write_u16le((right - left) as u16)?;
425 bw.write_u16le((bot - top) as u16)?;
427 bw.write_byte(0)?; // flags
429 let maxclr = pic.iter().fold(0u8, |acc, &a| acc.max(a));
430 let clr_bits = if maxclr > 128 {
434 while (1 << bits) < maxclr {
439 bw.write_byte(0x80 | (clr_bits - 1))?;
440 bw.write_buf(&cur_pal[..(3 << clr_bits)])?;
442 self.lzw.compress(&mut bw, pic)?;
444 self.write_dummy_frame(&mut bw)?;
448 NABufferType::None if !self.first => {
449 self.write_dummy_frame(&mut bw)?;
451 _ => return Err(EncoderError::InvalidParameters),
454 self.pkt = Some(NAPacket::new(self.stream.clone().unwrap(), frm.ts, self.first, dbuf));
457 if let NABufferType::Video(ref buf) = frm.get_buffer() {
458 let paloff = buf.get_offset(1);
459 let data = buf.get_data();
460 let mut pal = [0; 1024];
461 let srcpal = &data[paloff..][..768];
462 for (dclr, sclr) in pal.chunks_exact_mut(4).zip(srcpal.chunks_exact(3)) {
463 dclr[..3].copy_from_slice(sclr);
465 if let Some(ref mut pkt) = &mut self.pkt {
466 pkt.side_data.push(NASideData::Palette(true, Arc::new(pal)));
470 std::mem::swap(&mut self.cur_frm, &mut self.prev_frm);
473 fn get_packet(&mut self) -> EncoderResult<Option<NAPacket>> {
475 std::mem::swap(&mut self.pkt, &mut npkt);
478 fn flush(&mut self) -> EncoderResult<()> {
483 const ENCODER_OPTS: &[NAOptionDefinition] = &[
485 name: "compr", description: "Compression level",
486 opt_type: NAOptionDefinitionType::String(Some(&["none", "fast", "best"])) },
488 name: "inter_transparent", description: "Code changed regions with transparency",
489 opt_type: NAOptionDefinitionType::Bool },
491 name: "transparent_idx", description: "Palette index to use for transparency (on inter frames too if requested)",
492 opt_type: NAOptionDefinitionType::Int(Some(-1), Some(255)) },
495 impl NAOptionHandler for GIFEncoder {
496 fn get_supported_options(&self) -> &[NAOptionDefinition] { ENCODER_OPTS }
497 fn set_options(&mut self, options: &[NAOption]) {
498 for option in options.iter() {
499 for opt_def in ENCODER_OPTS.iter() {
500 if opt_def.check(option).is_ok() {
503 if let NAValue::String(ref strval) = option.value {
504 match strval.as_str() {
505 "none" => self.lzw.level = CompressionLevel::None,
506 "fast" => self.lzw.level = CompressionLevel::Fast,
507 "best" => self.lzw.level = CompressionLevel::Best,
512 "inter_transparent" => {
513 if let NAValue::Bool(bval) = option.value {
517 "transparent_idx" => {
518 if let NAValue::Int(ival) = option.value {
519 self.tr_idx = if ival >= 0 { Some(ival as u8) } else { None };
528 fn query_option_value(&self, name: &str) -> Option<NAValue> {
530 "compr" => Some(NAValue::String(self.lzw.level.to_string())),
531 "inter_transparent" => Some(NAValue::Bool(self.p_trans)),
532 "transparent_idx" => Some(NAValue::Int(self.tr_idx.map_or(-1i64, i64::from))),
538 pub fn get_encoder() -> Box<dyn NAEncoder + Send> {
539 Box::new(GIFEncoder::new())
544 use nihav_core::codecs::*;
545 use nihav_core::demuxers::*;
546 use nihav_core::muxers::*;
548 use nihav_codec_support::test::enc_video::*;
550 // sample: https://samples.mplayerhq.hu/V-codecs/Uncompressed/8bpp.avi
551 fn test_gif_encoder_single(out_name: &'static str, enc_options: &[NAOption], hash: &[u32; 4]) {
552 let mut dmx_reg = RegisteredDemuxers::new();
553 generic_register_all_demuxers(&mut dmx_reg);
554 let mut dec_reg = RegisteredDecoders::new();
555 generic_register_all_decoders(&mut dec_reg);
556 let mut mux_reg = RegisteredMuxers::new();
557 generic_register_all_muxers(&mut mux_reg);
558 let mut enc_reg = RegisteredEncoders::new();
559 generic_register_all_encoders(&mut enc_reg);
561 let dec_config = DecoderTestParams {
563 in_name: "assets/Misc/8bpp.avi",
564 stream_type: StreamType::Video,
568 let enc_config = EncoderTestParams {
574 let dst_vinfo = NAVideoInfo {
581 let enc_params = EncodeParameters {
582 format: NACodecTypeInfo::Video(dst_vinfo),
589 //test_encoding_to_file(&dec_config, &enc_config, enc_params, enc_options);
590 test_encoding_md5(&dec_config, &enc_config, enc_params, enc_options, hash);
592 // sample: https://samples.mplayerhq.hu/image-samples/GIF/3D.gif
593 fn test_gif_anim(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/3D.gif",
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);
635 fn test_gif_single_none() {
637 NAOption { name: "compr", value: NAValue::String("none".to_string()) },
639 test_gif_encoder_single("none.gif", enc_options, &[0x2767a289, 0xdef9ad30, 0xca4c289b, 0x1fd0ec19]);
642 fn test_gif_single_fast() {
644 NAOption { name: "compr", value: NAValue::String("fast".to_string()) },
646 test_gif_encoder_single("fast.gif", enc_options, &[0x9644f682, 0x497593cd, 0xdabb483d, 0x8fce63f4]);
649 fn test_gif_single_best() {
651 NAOption { name: "compr", value: NAValue::String("best".to_string()) },
653 test_gif_encoder_single("best.gif", enc_options, &[0x9644f682, 0x497593cd, 0xdabb483d, 0x8fce63f4]);
656 fn test_gif_anim_opaque() {
658 NAOption { name: "compr", value: NAValue::String("fast".to_string()) },
660 test_gif_anim("anim-opaque.gif", enc_options, &[0x58489e31, 0x1721d75e, 0xaebf93f2, 0x3fea9c6e]);
663 fn test_gif_anim_transparent() {
665 NAOption { name: "compr", value: NAValue::String("fast".to_string()) },
666 NAOption { name: "inter_transparent", value: NAValue::Bool(true) },
667 NAOption { name: "transparent_idx", value: NAValue::Int(0x7F) },
669 test_gif_anim("anim-transp.gif", enc_options, &[0x62df6232, 0x0c334457, 0x73738404, 0xa8829dcc]);