add LZF compressor

Author: 15045120

src/main/java/com/github/myibu/algorithm/compress/LZFCompressor.java

@@ -0,0 +1,128 @@
+package com.github.myibu.algorithm.compress;
+
+import java.nio.charset.StandardCharsets;
+
+public class LZFCompressor {
+    private static final int LZF_HSLOT_BIAS = 0;
+
+    private static final int HLOG = 16;
+    private static final int HSIZE = (1 << HLOG);
+
+    private static final int MAX_LIT = (1 <<  5);
+    private static final int MAX_OFF = (1 << 13);
+    private static final int MAX_REF = ((1 << 8) + (1 << 3));
+
+    private static int FRST(byte[] p, int offset) {
+        return ((p[offset+0] << 8) | p[offset+1]);
+    }
+
+    private static int NEXT(int v, byte[] p, int offset) {
+        return ((v << 8) | p[offset+2]);
+    }
+
+    private static int IDX(int h) {
+        return ((((h ^ (h << 5)) >> (3*8 - HLOG)) - h*5) & (HSIZE - 1));
+    }
+
+    public int compress(byte[] in_data, int in_len,
+                                byte[] out_data, int out_len) {
+        if (in_len == 0 || out_len == 0)
+            return 0;
+        int ip = 0, op = 0;
+        int lit;
+        lit = 0; op++; /* start run */
+        int hslot;
+        int[] htab = new int[HSIZE];
+        int ref;
+        int off;
+
+        int hval = FRST(in_data, ip);
+        while (ip < in_len - 2) {
+            hval = NEXT(hval, in_data, ip);
+            hslot = IDX(hval);
+            ref = htab[hslot];
+            htab[hslot] = ip;
+
+            if ((off = ip - ref - 1) < MAX_OFF
+                && ref > 0
+                && in_data[ref + 2] == in_data[ip + 2]
+                && ((in_data[ref+1] << 8) | in_data[ref+0]) == ((in_data[ip+1] << 8) | in_data[ip+0])) {
+                /* match found at *ref++ */
+                int len = 2;
+                int maxlen = in_len - ip - len;
+                maxlen = maxlen > MAX_REF ? MAX_REF : maxlen;
+
+                if (op + 3 + 1 >= out_len) /* first a faster conservative test */
+                    if (op - (lit==0 ? 1: 0) + 3 + 1 >= out_len) /* second the exact but rare test */
+                        return 0;
+
+                out_data[op- lit - 1] = (byte)(lit - 1); /* end run */
+                op -= (lit==0 ? 1: 0); /* undo run if length is zero */
+
+                do
+                    len++;
+                while (len < maxlen && in_data[ref+len] == in_data[ip+len]);
+
+                len -= 2; /* len is now #octets - 1 */
+                ip++;
+
+                if (len < 7) {
+                    out_data[op++] = (byte)((off >> 8) + (len << 5));
+                } else {
+                    out_data[op++] = (byte)((off >> 8) + (  7 << 5));
+                    out_data[op++] = (byte)(len - 7);
+                }
+
+                out_data[op++] = (byte)(off);
+
+                lit = 0; op++; /* start run */
+
+                ip += len+1;
+
+                if (ip >= in_len - 2)
+                    break;
+
+                hval = FRST(in_data, ip);
+
+                hval = NEXT(hval, in_data, ip);
+                htab[IDX(hval)] = ip - LZF_HSLOT_BIAS;
+                ip++;
+
+                ip -= len + 1;
+
+                do
+                {
+                    hval = NEXT(hval, in_data, ip);
+                    htab[IDX(hval)] = ip - LZF_HSLOT_BIAS;
+                    ip++;
+                }
+                while ((--len) > 0);
+            }
+            else {
+                lit++;
+                out_data[op++] = in_data[ip++];
+                if (lit == MAX_LIT) {
+                    out_data[op- lit - 1] = (byte)(lit - 1); /* stop run */
+                    lit = 0; op++; /* start run */
+                }
+            }
+        }
+
+        if (op + 3 > out_len) /* at most 3 bytes can be missing here */
+            return 0;
+
+        while (ip < in_len) {
+            lit++;
+            out_data[op++] = in_data[ip++];
+            if (lit == MAX_LIT) {
+                out_data[op- lit - 1] = (byte)(lit - 1); /* stop run */
+                lit = 0; op++; /* start run */
+            }
+        }
+
+        out_data[op- lit - 1] = (byte)(lit - 1); /* end run */
+        op -= (lit==0 ? 1: 0); /* undo run if length is zero */
+
+        return op;
+    }
+}

src/test/java/com/github/myibu/algorithm/AlgorithmTest.java

@@ -1,5 +1,6 @@
 package com.github.myibu.algorithm;
 
+import com.github.myibu.algorithm.compress.LZFCompressor;
 import com.github.myibu.algorithm.data.Bits;
 import com.github.myibu.algorithm.data.Bytes;
 import com.github.myibu.algorithm.filter.*;
@@ -15,6 +16,7 @@
 import org.junit.Test;
 
 import java.nio.charset.StandardCharsets;
+import java.util.Arrays;
 import java.util.Set;
 
 public class AlgorithmTest {
@@ -128,4 +130,28 @@ public void testSensitiveWordFilter() {
         filter1.addWords(Set.of("黄色", "绿色", "红色"));
         System.out.println(filter1.searchWords("昨天我过马路的时候先遇到红色灯，再遇到绿灯"));
     }
+
+    @Test
+    public void testLZFCompressor() {
+        /**
+         * 1111122222
+         * hex:    01-31-31-20-00-00-32-20-00-00-32
+         * binary: 01-49-49-32-00-00-50-32-00-00-50
+         *
+         * 111112222233333
+         * hex:    01-31-31-20-00-00-32-40-00-00-33-20-00-01-33-33
+         * binary: 01-49-49-32-00-00-50-64-00-00-51-32-00-01-51-51
+         *
+         * 111112222233333344444
+         * '01-31-31-20-00-00-32-40-00-00-33-60-00-00-34-20-00-00-34'
+         */
+//        [1, 49, 49, 32, 0, 32, 0, 0, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
+//        byte[] in_data = "1111122222".getBytes(StandardCharsets.UTF_8);
+
+        byte[] in_data = "111112222233333344444".getBytes(StandardCharsets.UTF_8);
+        byte[] out_data = new byte[in_data.length*2];
+        LZFCompressor com = new LZFCompressor();
+        com.compress(in_data, in_data.length, out_data, out_data.length);
+        System.out.println(Arrays.toString(out_data));
+    }
 }