算术编码的数据压缩

算术编码是无损和有损数据压缩算法中常用的一种算法。

这是一种熵编码技术，其中常见符号比罕见符号用更少的比特进行编码。与诸如霍夫曼编码之类的众所周知的技术相比，它具有一些优势。本文将详细描述CACM87算术编码的实现，让您很好地了解实现它所需的所有细节。

从历史的角度来看，这篇文章是我20多年前写的一篇关于算术编码的数据压缩文章的更新。这篇文章发表在多布博士期刊的印刷版上，这意味着为了避免过多的页数，我们进行了大量的编辑。特别是，多布博士的文章结合了两个主题：算术编码的描述，以及使用PPM（部分匹配预测）进行压缩的讨论。

因为这篇新文章将在网上发布，空间考虑不再是一个重要因素，我希望这能让我公正地对待算术编码的细节。PPM本身就是一个有价值的话题，将在后面的文章中讨论。我希望这项新的努力，虽然冗长得令人恼火，但将是对我在1991年想做的主题的彻底解释。

我认为理解算术编码的最好方法是将其分为两部分，我将在本文中使用这个想法。首先，我将描述算术编码是如何工作的，使用标准C++数据类型实现的常规浮点算术。这允许实现一个完全可以理解但有点不切实际的实现。换句话说，它是有效的，但它只能用于编码非常短的消息。

文章的第二部分将描述一种实现，在该实现中，我们切换到对无界二进制数进行特殊类型的数学运算。这本身就是一个有点令人难以置信的话题，所以如果你已经理解了算术编码，它会有所帮助——你不必为同时学习两件事而烦恼。

最后，我将介绍用现代C++编写的工作示例代码。它不一定是世界上优化程度最高的代码，但它是可移植的，很容易添加到现有项目中。它应该非常适合学习和试验这种编码技术。

基本原理

关于算术编码，首先要了解的是它产生了什么。算术编码采用由符号（几乎总是八位字符）组成的消息（通常是一个文件），并将其转换为大于或等于零且小于1的浮点数。这个浮点数字可能很长——实际上，整个输出文件都是一个长数字——这意味着它不是传统编程语言中习惯使用的普通数据类型。我的算法实现必须从头开始，一点一点地创建这个浮点数，同样地，一点地读入并解码它。

这个编码过程是逐步完成的。当文件中的每个字符都被编码时，一些比特将被添加到编码的消息中，因此随着算法的进行，它会随着时间的推移而建立起来。

关于算术编码，需要理解的第二件事是，它依赖于一个模型来表征它正在处理的符号。该模型的工作是告诉编码器给定消息中字符的概率是多少。如果模型给出了消息中字符的准确概率，那么它们将被编码为非常接近最优。如果模型歪曲了符号的概率，那么编码器实际上可能会扩展消息，而不是压缩它！

using System;

namespace Legalsoft.Truffer
{
    /// <summary>
    /// compression by arithmetic coding
    /// </summary>
    public class Arithcode
    {
        private int NWK { get; } = 20;
        private int nch { get; set; }
        private int nrad { get; set; }
        private int ncum { get; set; }
        private int jdif { get; set; }
        private int nc { get; set; }
        private int minint { get; set; }
        private int[] ilob { get; set; }
        private int[] iupb { get; set; }
        private int[] ncumfq { get; set; }

        public Arithcode(int[] nfreq, int nnch, int nnrad)
        {
            this.nch = nnch;
            this.nrad = nnrad;
            this.ilob = new int[NWK];
            this.iupb = new int[NWK];
            this.ncumfq = new int[nch + 2];

            if (nrad > 256)
            {
                throw new Exception("output radix must be <= 256 in Arithcode");
            }

            minint = (int)(int.MaxValue / nrad);
            ncumfq[0] = 0;
            for (int j = 1; j <= nch; j++)
            {
                ncumfq[j] = ncumfq[j - 1] + Math.Max(nfreq[j - 1], 1);
            }
            ncum = ncumfq[nch + 1] = ncumfq[nch] + 1;
        }

        public void messageinit()
        {
            jdif = (int)(nrad - 1);
            for (int j = NWK - 1; j >= 0; j--)
            {
                iupb[j] = nrad - 1;
                ilob[j] = 0;
                nc = (int)j;
                if (jdif > minint)
                {
                    return;
                }
                jdif = (int)((jdif + 1) * nrad - 1);
            }
            throw new Exception("NWK too small in arcode.");
        }

        public void codeone(int ich, byte[] code, ref int lcd)
        {
            if (ich > nch)
            {
                throw new Exception("bad ich in Arithcode");
            }
            advance(ich, code, ref lcd, 1);
        }

        public int decodeone(byte[] code, ref int lcd)
        {
            int ja = (byte)code[lcd] - ilob[nc];
            for (int j = nc + 1; j < NWK; j++)
            {
                ja *= (int)nrad;
                ja += (byte)code[lcd + j - nc] - ilob[j];
            }
            int ihi = (int)(nch + 1);
            int ich = 0;
            while (ihi - ich > 1)
            {
                int m = (int)((ich + ihi) >> 1);
                if (ja >= multdiv(jdif, ncumfq[m], (int)ncum))
                {
                    ich = (int)m;
                }
                else
                {
                    ihi = m;
                }
            }
            if (ich != nch)
            {
                advance(ich, code, ref lcd, -1);
            }
            return ich;
        }

        public void advance(int ich, byte[] code, ref int lcd, int isign)
        {
            int jh = multdiv(jdif, ncumfq[ich + 1], (int)ncum);
            int jl = multdiv(jdif, ncumfq[ich], (int)ncum);
            jdif = jh - jl;
            arrsum(ilob, iupb, jh, NWK, (int)nrad, nc);
            arrsum(ilob, ilob, jl, NWK, (int)nrad, nc);
            int j = nc;
            for (; j < NWK; j++)
            {
                if (ich != nch && iupb[j] != ilob[j])
                {
                    break;
                }
                if (isign > 0)
                {
                    code[lcd] = (byte)ilob[j];
                }
                lcd++;
            }
            if (j + 1 > NWK)
            {
                return;
            }
            nc = j;
            for (j = 0; jdif < minint; j++)
            {
                jdif *= (int)nrad;
            }
            if (j > nc)
            {
                throw new Exception("NWK too small in arcode.");
            }
            if (j != 0)
            {
                for (int k = nc; k < NWK; k++)
                {
                    iupb[k - j] = iupb[k];
                    ilob[k - j] = ilob[k];
                }
            }
            nc -= j;
            for (int k = (int)(NWK - j); k < NWK; k++)
            {
                iupb[k] = ilob[k] = 0;
            }
            return;
        }

        public int multdiv(int j, int k, int m)
        {
            return (int)((ulong)j * (ulong)k / (ulong)m);
        }

        public void arrsum(int[] iin, int[] iout, int ja, int nwk, int nrad, int nc)
        {
            int karry = 0;
            for (int j = (int)(nwk - 1); j > nc; j--)
            {
                int jtmp = ja;
                ja /= nrad;
                iout[j] = iin[j] + (jtmp - ja * nrad) + karry;
                if (iout[j] >= nrad)
                {
                    iout[j] -= nrad;
                    karry = 1;
                }
                else
                {
                    karry = 0;
                }
            }
            iout[nc] = iin[nc] + ja + karry;
        }
    }
}