likes
comments
collection
share

Java实现视频初步压缩和解压

作者站长头像
站长
· 阅读数 34

本文主要做了什么

从摄像头读取每一帧的图片，用一些简单的方法将多张图片信息压缩到一份文件中（自定义的视频文件），自定义解码器读取视频文件，并将每帧图片展示成视频

第一步：按照某些算法帧内压缩

常见的视频压缩算法（H264，H265，MP4）过程很复杂，实现的压缩比率也很恐怖（H265可以做到0.5%的压缩率，也就是就算每帧图片加起来有2个GB，合并起来的视频也就10MB），其中压缩算法流程大致如下，我的程序没有细究算法，简单实现了25%的压缩率。

帧内压缩：
  1. 帧分割： 将原本RGB格式的图像用YUV表示，用YUV是将原本的像素信息转化成亮度和色度信息，由于人眼对色度的变化并不敏感，所以YUV可以在多个像素点之上采用同一数据以实现数据压缩。具体的做法是：将原本图片分成22 / 44 / 88 / 1616的宏块，每个宏块（4*4为例）内按照YUV格式数据采集——记录每个像素格的亮度Y，记录每横向两个像素格的色度U，记录每个宏块左上角像素各的色度V。算法将Y，U，V分别存储，再在接收端分别取出某个宏块对应的数据，恢复成YUV，再恢复成RGB。
  2. 帧内预测： 邻近的宏块之间可以进行预测，算法思想是由一个宏块，通过某种预测模式，得到一个预测的模块，将实际值和预测值之间的残差进行保存。
  3. 离散余弦变换（DCT） 对每个块的残差执行DCT变换，算法思想是：图像数据分为细节、纹理和快速变化这类的高频信息，和像整体趋势、平均值和慢速变化这类低频信息；DCT主要保留包含了数据整体特征的低频信息。
  4. 量化： 由于DCT的结果中浮点数较多，量化将其截断为整数以减少数据量
  5. 熵编码： 熵编码用于编码多种类型的信息，像文本、图像、音频等信息根据数据的概率分布（如字符、像素、采样值）映射为可变长度的编码。经典哈夫曼树就是一种实现。在此就是将像素值/YUV值根据其概率分布设置不同编码。
帧间压缩：
  1. 帧间预测： 由于很多帧之间存在冗余，算法首先选择一个参考帧，然后计算参考帧和当前帧之间的运动矢量，由此去除冗余信息
  2. 运动补偿...
  3. 残差计算...
  4. ...

我的代码：

  1. 主要Controller： 
    @GetMapping("/compressedVideos")
public void getCompressedBytes() throws IOException {
	//录制5秒的视频，存在List中
    webcam.open();
    long startTime = System.currentTimeMillis();
    List<BufferedImage> bufferedImages = new ArrayList<>();
    while (System.currentTimeMillis() - startTime < 5000) {
        BufferedImage image = webcam.getImage();
        bufferedImages.add(image);
    }
    System.out.println("录制结束");
    webcam.close();
    //调用压缩方法，将结果写入文件中
    byte[] bytes = outerCompressionUtils.photosToCompressedBytes(bufferedImages);
    File file = new File("压缩中的压缩.dat");
    FileOutputStream fos = new FileOutputStream(file);
    fos.write(bytes);
    fos.close();
    System.out.println("持久化结束");
}
  2. 压缩：
    1. 工具方法：将rgb转化成YUV
    public static int[] rgb2YUV(int rgb) {
    int[] rgb1 = photoOps.RGBToInts(rgb);
    int red = rgb1[0];
    int green = rgb1[1];
    int blue = rgb1[2];

    int Y = (int) (0.299 * red + 0.587 * green + 0.114 * blue -128); //-128 到 127
    int U = (int) (-0.1684 * red - 0.3316 * green + 0.5 * blue);//-128 到 127
    int V = (int) (0.5 * red - 0.4187 * green - 0.083 * blue); //-128 到 127

    return new int[]{Y, U, V};
}
    1. 工具方法：一张图片化成YUV
    public static byte[] compressToOneChannel(BufferedImage bufferedImage) {

    byte[] Ys = new byte[bufferedImage.getWidth() * bufferedImage.getHeight()];
    byte[] Us = new byte[bufferedImage.getHeight() * (bufferedImage.getWidth() / 2)];
    byte[] Vs = new byte[(bufferedImage.getWidth() / 2) * (bufferedImage.getHeight() / 2)];

    int targetYs = 0;
    int targetUs = 0;
    int targetVs = 0;

	/*
	这里就是遍历2*2的宏块，将其中对应YUV分别写到YUV的数组中
	需要注意的是我犯的一个错误：没有注意到Y和U的遍历过程，导致在解码的时候图片异常
	*/
    for (int i = 0; i < bufferedImage.getHeight(); i += 2) {
        for (int j = 0; j < bufferedImage.getWidth(); j += 2) {
            for (int k = 0; k < 2; k++) {
                for (int l = 0; l < 2; l++) {
                    int[] ints = rgb2YUV(bufferedImage.getRGB(j + l, i + k));
                    int Y = ints[0];
                    Ys[targetYs] = (byte) (Y);
                    targetYs++;
                }
                int[] ints = rgb2YUV(bufferedImage.getRGB(j, i + k));
                int U = ints[1];
                Us[targetUs] = (byte) (U);
                targetUs++;
            }
            int[] ints = rgb2YUV(bufferedImage.getRGB(j, i));
            int V = ints[2];
            Vs[targetVs] = (byte) (V);
            targetVs++;
        }

    }
    int length1 = Ys.length; //大小估计 ： 图片3000*2000 = 6000000 不会超int范围
    int length2 = Us.length;
    int length3 = Vs.length;


    byte[] targetBytes = new byte[4 * 5 + length1 + length2 + length3];
    int targetIndex = 0;
	
	//这里是将byte[]开头填充一些用于解码的信息，因为Ys，Us，Vs都是一起传的，需要在包开头标明每个数组长度
	//Y区的长度
    byte[] bytes1 = intToByte(length1);
    for (byte b : bytes1) {
        targetBytes[targetIndex] = b;
        targetIndex++;
    }
    //U区长度
    byte[] bytes2 = intToByte(length2);
    for (byte b : bytes2) {
        targetBytes[targetIndex] = b;
        targetIndex++;
    }
    //V区长度
    byte[] bytes3 = intToByte(length3);
    for (byte b : bytes3) {
        targetBytes[targetIndex] = b;
        targetIndex++;
    }
    //图片的高
    byte[] bytes4 = intToByte(bufferedImage.getHeight());
    for (byte b : bytes4) {
        targetBytes[targetIndex] = b;
        targetIndex++;
    }
    //图片的宽
    byte[] bytes5 = intToByte(bufferedImage.getWidth());
    for (byte b : bytes5) {
        targetBytes[targetIndex] = b;
        targetIndex++;
    }

	//传递真实数据
    for (byte y : Ys) {
        targetBytes[targetIndex] = y;
        targetIndex++;
    }

    for (byte u : Us) {
        targetBytes[targetIndex] = u;

        targetIndex++;
    }

    for (byte v : Vs) {
        targetBytes[targetIndex] = v;
        targetIndex++;
    }
    return targetBytes;

}
  3. 工具方法：多张图片化成YUV并压缩 
    public static byte[] photosToCompressedBytes(List<BufferedImage> bufferedImages) throws IOException {

    //数据流中未必要有各种辅助信息，比如各类字段长度，在外规定好算了
    //这里每一帧的长度就是：20 + 640 * 480 * 1.75
    ByteArrayOutputStream baos = new ByteArrayOutputStream();
    //java提供的压缩工具，此输出流将输出的东西压缩输出
    //传入的Deflater对象用于控制压缩算法
    DeflaterOutputStream dos = new DeflaterOutputStream(baos,new Deflater());

	//帧信息添加到压缩流
    for (BufferedImage bufferedImage: bufferedImages
         ) {
        byte[] bytes = innerCompressionUtils.compressToOneChannel(bufferedImage);
        System.out.println("一帧的长度为："+bytes.length);
        dos.write(bytes);
    }
    byte[] compressedData = baos.toByteArray();
    return compressedData;
}
  4. 尝试用哈夫曼编码优化
class HuffmanNode implements Comparable<HuffmanNode>{

    byte value;
    int frequency;

    HuffmanNode left;
    HuffmanNode right;

    public HuffmanNode(byte value,int frequency){
        this.value = value;
        this.frequency = frequency;
    }

    @Override
    public int compareTo(@NotNull HuffmanNode o) {
        return this.frequency - o.frequency;
    }
}

public class Huffman {

    public static Map<Byte,String> encodingTable;

    public static String huffmanEncoding(byte[] originalBytes){
        Map<Byte,Integer> frequencyMap = new HashMap<>();

        for (byte b: originalBytes
             ) {
            frequencyMap.put(b, frequencyMap.getOrDefault(b,0)+1);
        }
        PriorityQueue<HuffmanNode> minHeap = new PriorityQueue<>();

        for (Map.Entry<Byte, Integer> entry : frequencyMap.entrySet()
                ) {
            minHeap.add(new HuffmanNode(entry.getKey(),entry.getValue()));
        }
        while (minHeap.size()>1){
            HuffmanNode left = minHeap.poll();
            HuffmanNode right = minHeap.poll();

            HuffmanNode mergeNode = new HuffmanNode((byte)0, left.frequency + right.frequency);
            mergeNode.left = left;
            mergeNode.right = right;

            minHeap.add(mergeNode);
        }
        encodingTable = new HashMap<>();
        HuffmanNode root = minHeap.poll();

        buildEncodingTable(root,"",encodingTable);

        StringBuilder encodingData = new StringBuilder();
        for (Byte b: originalBytes
             ) {
            encodingData.append(encodingTable.get(b));
        }
        System.out.println("原始数组长度"+originalBytes.length);
        System.out.println("哈夫曼后数组长度"+encodingData.length());
        return encodingData.toString();

    }

public static void buildEncodingTable(HuffmanNode node,String currentCode,Map<Byte,String> encodingMap) {

        if (node == null) {
            return;
        }
        if (node.left == null && node.right == null) {
            encodingMap.put(node.value, currentCode);
        } else {
            buildEncodingTable(node.left, currentCode + "0", encodingMap);
            buildEncodingTable(node.right, currentCode + "1", encodingMap);
        }
    }

但其实这里用哈夫曼并不会优化数据量，原因如下： 我传输的数据是-128到127的byte类型，这些byte来自图片的亮度和色度，调试中发现这255个数字出现的频率差不多,全部都在14万到20万之间，两个最小值加起来任然比最大值大，这就意味着这颗哈夫曼树会比较满，类似完全二叉树，于是就无法区分出现频率最高的某个字符。

另外，原本255个数将8位byte全都占满，假如有一个频率很高的元素，我们把较短的0101赋给它，那势必会导致原本以0101开头的元素用8位以上的长度进行表示，而程序中各元素出现频率相近，这就会导致如果有元素用短于8位的编码，其他长于8位编码的元素会导致数据更加庞大。

我在用huffman编码后，数据量一点都没有变，只是由长度为40647865的byte数组变成长度为325182920的字符串，其实就是×8 。怀疑是代码哪里错了...

常见的压缩算法是将DCT变换后的结果进行哈夫曼编码，DCT变换后低频信息和高频信息自然区分开，确实更适合这个熵编码方法

Java实现视频初步压缩和解压 Java实现视频初步压缩和解压

  1. 解压：
    1. 先将java zip包的压缩过程解压
public static InflaterInputStream inflaterCompressedBytes(byte[] bytes) throws IOException {
        //解压数据
        ByteArrayInputStream bais = new ByteArrayInputStream(bytes);
        
        InflaterInputStream lis = new InflaterInputStream(bais, new Inflater());
        
        return lis;
    }
  1. 依据压缩时自定义的格式进行对byte数组解析
public static BufferedImage getBfi(byte[] originalBytes) {
		//分别先把开头表示各个区长度以及图片宽高的参数取出来
        byte one = originalBytes[0];
        byte two = originalBytes[1];
        byte three = originalBytes[2];
        byte four = originalBytes[3];

        int Y = ((one & 0xff) << 24) | ((two & 0xff) << 16) | ((three & 0xff) << 8) | (four & 0xff);

        byte one2 = originalBytes[4];
        byte two2 = originalBytes[5];
        byte three2 = originalBytes[6];
        byte four2 = originalBytes[7];

        int U = ((one2 & 0xff) << 24) | ((two2 & 0xff) << 16) | ((three2 & 0xff) << 8) | (four2 & 0xff);
        byte one3 = originalBytes[8];
        byte two3 = originalBytes[9];
        byte three3 = originalBytes[10];
        byte four3 = originalBytes[11];

        int V = ((one3 & 0xff) << 24) | ((two3 & 0xff) << 16) | ((three3 & 0xff) << 8) | (four3 & 0xff);

        byte one4 = originalBytes[12];
        byte two4 = originalBytes[13];
        byte three4 = originalBytes[14];
        byte four4 = originalBytes[15];

        int height = ((one4 & 0xff) << 24) | ((two4 & 0xff) << 16) | ((three4 & 0xff) << 8) | (four4 & 0xff);

        byte one5 = originalBytes[16];
        byte two5 = originalBytes[17];
        byte three5 = originalBytes[18];
        byte four5 = originalBytes[19];

        int width = ((one5 & 0xff) << 24) | ((two5 & 0xff) << 16) | ((three5 & 0xff) << 8) | (four5 & 0xff);

        System.out.println("Y: " + Y);

		//将数据读取出来
        byte[] Ys = Arrays.copyOfRange(originalBytes, 20, Y + 20);
        byte[] Us = Arrays.copyOfRange(originalBytes, Y + 20, Y + U + 20);
        byte[] Vs = Arrays.copyOfRange(originalBytes, Y + U + 20, Y + U + V + 20);

        BufferedImage bfi = new BufferedImage(width, height, BufferedImage.TYPE_INT_RGB);
        int hongW = width / 2;
        int hongH = height / 2;

		//用YUV数据恢复成RGB，填充到图片的每一个像素
        for (int i = 0; i < height - 1; i++) {
            for (int j = 0; j < width - 1; j++) {
                int H = i / 2;
                int W = j / 2;
                byte y = Ys[(i / 2 * 2) * width + j / 2 * 4 + (i % 2) * 2 + j % 2];
                byte u = Us[H * hongW * 2 + j / 2 * 2 + i % 2];
                byte v = Vs[H * hongW + W];

                int r = (int) (y + 128 + 1.14075 * (v));
                int g = (int) (y + 128 - 0.3455 * (u) - 0.7169 * (v));
                int b = (int) (y + 128 + 1.779 * (u));

                r = Math.min(255, Math.max(0, r));
                g = Math.min(255, Math.max(0, g));
                b = Math.min(255, Math.max(0, b));

                int color = (r) << 16 | (g) << 8 | b;
                if (i < 1 && j < 20) {
                bfi.setRGB(j, i, color);
            }
        }
        return bfi;
    }
  1. 简单的播放器（基于Swing）
FileInputStream fileInputStream = new FileInputStream("C:\\Users\\吴松林\\IdeaProjects\\meitu2\\压缩中的压缩.dat");
        ByteArrayOutputStream outputStream = new ByteArrayOutputStream(); //此输出流中写入所有信息，最后转出为byte[]，类似桶子
        byte[] buffer = new byte[1024];
        int bytesRead;
        while ((bytesRead = fileInputStream.read(buffer))!=-1){
            outputStream.write(buffer,0,bytesRead);
        }
        byte[] data = outputStream.toByteArray();

        InflaterInputStream iutputStream1 = utils.inflaterCompressedBytes(data); //解压
        BufferedInputStream bis = new BufferedInputStream(iutputStream1);
        List<BufferedImage> bufferedImages = new ArrayList<>();
        byte[] eachImage = new byte[(int) (20+640*480*1.75)];
        int testIndex = 0;
        int index;
        System.out.println("length: "+eachImage.length);
        try {
            while ((index = bis.read(eachImage)) != -1) {
                System.out.println("本次读取长度：" + index);
                testIndex++;
                System.out.println("test: " + testIndex);
                BufferedImage bfi = utils.getBfi(eachImage);
                bufferedImages.add(bfi);
            }
        }catch (Exception e){
            System.out.println("跳过异常，省略最后一张图片");
            e.printStackTrace();
        }
        bis.close();
        iutputStream1.close();
        outputStream.close();
        fileInputStream.close();

        JFrame jFrame = new JFrame();
        myPanel panel = new myPanel();
        jFrame.add(panel);
        jFrame.setSize(new Dimension(640,480));
        jFrame.setVisible(true);

        panel.list = bufferedImages;
        while (true){
            panel.repaint();
        }

    }
}
class myPanel extends JPanel{

    int index = 0;

    List<BufferedImage> list;
    @Override
    public void paint(Graphics g) {
        g.drawImage(list.get(index), 0, 0, null);
        if (index < list.size() - 2) {
            index++;
        }
        try {
            Thread.sleep(34);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
    }
}

注意：

  1. zip包在使用时我遇到报：Unexpected end of ZLIB input stream，没找到很合适的解决办法，但发现这个异常是在读取到最后一张图片时才触发，于是我选择舍弃最后一张图
  2. 这个播放器只用Swing简单写了一个用于测试能否读取文件，很明显我的播放器只能播放我的视频，因为其解码方式和编码方式息息相关，而各种常见的编码方式里的算法又太过复杂。所以这个程序就相当于写着玩而已，和其他视频/播放器难有半点干系。
转载自:https://juejin.cn/post/7282949699178709011
评论
请登录