C# 可变长度整数编码

我正在尝试对LZ1/LZ77解压算法进行反向工程。要输出的解码缓冲区/窗口区域的长度在文件中编码为可变长度整数。我已经尽可能多地阅读了关于可变长度整数编码的内容，本例中使用的方法与我见过的任何其他方法都不一样。也许是为了避免专利问题，也许只是为了混淆。所包含的代码可能不太完整，但目前至少正在处理几个文件

我看不出，如果有的话，下面使用的公式怎么能简化成更简单的东西。大多数可变长度整数编码算法使用某种循环，但对于这一种，我无法做到这一点，因为在计算每个半字节时，公式似乎并不一致

非常感谢您的建议

private static int getLength(BitReader bitStream)
{
    const int minSize = 2;

    int length = 0;

    byte nibble3, nibble2, nibble1;

    nibble3 = bitStream.ReadNibble();

    if (nibble3 >= 0xc)
    {
        nibble2 = bitStream.ReadNibble();
        nibble1 = bitStream.ReadNibble();

        if (nibble3 == 0xF & nibble2 == 0xF & nibble1 == 0xF) return -1;

        if ((nibble3 & 2) != 0)
        {
            length = (((((nibble3 & 7) + 3) << 6) + 8)) + 
                ((nibble2 & 7) << 3) + nibble1 + minSize;
        }
        else if ((nibble3 & 1) != 0)
        {
            length = (((nibble3 & 7) << 6) + 8) + 
                ((((nibble2 & 7)) + 1) << 3) + nibble1 + minSize;
        }
        else
        {
            length = ((((nibble3 & 7) << 4) + 8)) + 
                ((nibble2 & 7) << 4) + nibble1 + minSize;
        }
    }
    else if ((nibble3 & 8) != 0)
    {
        nibble1 = bitStream.ReadNibble();

        length = ((((nibble3 & 7) << 1) + 1) << 3) + nibble1 + minSize;
    }
    else
    {
        length = nibble3 + minSize;
    }

    return length;
}

private static int getLength（位读取器位流）
{
const int minSize=2；
整数长度=0；
字节nibble3，nibble2，nibble1；
nibble3=位流。ReadNibble（）；
如果（半字节3>=0xc）
{
nibble2=位流。ReadNibble（）；
nibble1=位流。ReadNibble（）；
if（nibble3==0xF&nibble2==0xF&nibble1==0xF）返回-1；
如果（（小口3和2）！=0）
{
length=（（（nibble3&7）+3）事实证明，所使用的可变长度整数编码算法与该方法非常相似。事实上，需要进行多个计算，而不是一个公式

基于此，我重新编写了如下代码。我仍在尝试找出使用前导0xFFF的机制的确切格式

    private static int getLength(BitReader bitStream)
    {
        const int minSize = 2;
        int length = 0;
        byte nibble3, nibble2, nibble1;
        byte nibble;
        nibble = bitStream.ReadNibble();
        if (nibble == 0xF)
        {
            nibble2 = bitStream.ReadNibble();
            nibble1 = bitStream.ReadNibble();
            if (nibble2 == 0xf && nibble1 == 0xF)
            {
                //The next nibble specifies the number of nibbles to be read, maybe.
                byte nibblesToRead = (byte) (bitStream.ReadNibble()) ;
                //The Dlugosz' mechanism would use a mask on the value but that doesn't appear to be the case here.
                //nibblesToRead &= 7;
                //switch (nibblesToRead & 7){
                //    case 0: nibblesToRead = 5; break;
                //    case 1: nibblesToRead = 8; break;
                //    case 2: nibblesToRead = 16; break;                           
                //}
                byte value=0;
                byte[] values = new byte[nibblesToRead];
                bool c=true;
                for (int i = 0; i < nibblesToRead; i++)
                {
                    value = bitStream.ReadNibble();
                    //values[i] = value;
                    length += (((value << 1) | 1) << 3);
                }
                value = bitStream.ReadNibble();
                length += value;
            }
        }
        else if((nibble >= 0xC)){
           nibble2 = bitStream.ReadNibble();
           nibble1 = bitStream.ReadNibble();
           length = ((((((nibble & 1) <<1)|1))<< 3) + ((nibble2<<1)|1)<<3)+nibble1;
        }
        else if ((nibble & 8)!=0){
            nibble1 = bitStream.ReadNibble();
            length = ((((nibble & 3)<<1) | 1) << 3) + nibble1;
        }
        else{
            length=nibble;
        }
        return length + minSize;
      };

private static int getLength（位读取器位流）
{
const int minSize=2；
整数长度=0；
字节nibble3，nibble2，nibble1；
字节半字节；
nibble=bitStream.ReadNibble（）；
if（半字节==0xF）
{
nibble2=位流。ReadNibble（）；
nibble1=位流。ReadNibble（）；
if（nibble2==0xf&&nibble1==0xf）
{
//下一个半字节可能指定要读取的半字节数。
字节nibblesToRead=（字节）（bitStream.ReadNibble（））；
//Dlugosz机制将在值上使用掩码，但这里的情况似乎不是这样。
//啃食头&=7；
//开关（nibblesToRead和7）{
//案例0:nibblesToRead=5；中断；
//案例1:nibblesToRead=8；中断；
//案例2:nibblesToRead=16；中断；
//}
字节值=0；
字节[]值=新字节[nibblesToRead]；
bool c=真；
for（int i=0；ilength+=（（值）是否允许对此进行反向工程？是的。这是我数据库中的数据。我不是在反汇编源应用程序，只是在处理我自己的数据。