HEVAG.cs

        private int min, ShM, s1, s2, s3, s4, tS1, tS2, tS3, tS4, PrNRf;
        private int VAG_1, VAG_2, HEVAG_1, HEVAG_2, HEVAG_3, HEVAG_4;
        private int[] data_buffer, error, four_bit, max, temp_buffer;
        private int* data_bufferPtr, errorPtr, four_bitPtr, maxPtr, temp_bufferPtr;
        private int[] S_1, S_2, S_3, S_4, S1, S2, S3, S4;
        private int* S_1Ptr, S_2Ptr, S_3Ptr, S_4Ptr, S1Ptr, S2Ptr, S3Ptr, S4Ptr;

        private void DecodeHEVAG()
        {
            i = 0; i2 = 1;
            while (i < BS)
            {
                d0 = four_bitPtr[i ];
                d1 = four_bitPtr[i2];
                if (d0 > 7) d0 -= 16;
                if (d1 > 7) d1 -= 16;
                d0 <<= 20 - ShF;
                d1 <<= 20 - ShF;

                g = ((tS1 >> 8) * HEVAG_1 + (tS2 >> 8) * HEVAG_2 +
                     (tS3 >> 8) * HEVAG_3 + (tS4 >> 8) * HEVAG_4) >> 5;
                tS4 = tS3; tS3 = tS2; tS2 = tS1; tS1 = g + d0;

                g = ((tS1 >> 8) * HEVAG_1 + (tS2 >> 8) * HEVAG_2 +
                     (tS3 >> 8) * HEVAG_3 + (tS4 >> 8) * HEVAG_4) >> 5;
                tS4 = tS3; tS3 = tS2; tS2 = tS1; tS1 = g + d1;

                temp_bufferPtr[i ] = tS2;
                temp_bufferPtr[i2] = tS1;
                i  += 2;
                i2 += 2;
            }
        }

        private void Calc4BitsHEVAG()
        {
            PrNRf = 0;
            min   = 0x7FFFFFFF;
            for (j = 0; j < PrNRCount; j++)
            {
                PrNR = j;

                Calc4Bits_HEVAG();

                tS1 = S1Ptr[c]; tS2 = S2Ptr[c]; tS3 = S3Ptr[c]; tS4 = S4Ptr[c];
                DecodeHEVAG();
                i = 0;
                errorPtr[j] = 0;
                while (i < BS)
                {
                    e = data_bufferPtr[i] - temp_bufferPtr[i];
                    if (e < 0) e = -e;
                    errorPtr[j] += e;
                    i++;
                }

                if (errorPtr[j] < min) { PrNRf = j; min = errorPtr[j]; }
            }
            PrNR = PrNRf;

            Calc4Bits_HEVAG();
             S1Ptr[c] =  s1;  S2Ptr[c] =  s2;  S3Ptr[c] =  s3;  S4Ptr[c] =  s4;
            S_1Ptr[c] = tS1; S_2Ptr[c] = tS2; S_3Ptr[c] = tS3; S_4Ptr[c] = tS4;
        }

        private void Calc4Bits_HEVAG()
        {
            s1 = S1Ptr[c]; s2 = S2Ptr[c]; s3 = S3Ptr[c]; s4 = S4Ptr[c];
            HEVAG_1 = HEVAG1Ptr[PrNR]; HEVAG_2 = HEVAG2Ptr[PrNR];
            HEVAG_3 = HEVAG3Ptr[PrNR]; HEVAG_4 = HEVAG4Ptr[PrNR];

            i = 0;
            maxPtr[PrNR] = 0;
            while (i < BS)
            {
                g = data_bufferPtr[i];
                e = ((s1 >> 8) * HEVAG_1 + (s2 >> 8) * HEVAG_2 +
                     (s3 >> 8) * HEVAG_3 + (s4 >> 8) * HEVAG_4) >> 5;
                e = g - e;
                if (e >  7864319) e =  7864319;
                if (e < -7864320) e = -7864320;
                temp_bufferPtr[i] = e;
                if (e < 0) e = -e;
                if (e > maxPtr[PrNR]) maxPtr[PrNR] = e;
                s4 = s3; s3 = s2; s2 = s1; s1 = g;
                i++;
            }

            for (ShF = 0, ShM = 0x400000; ShF < 15; ShF++, ShM >>= 1)
            { e = maxPtr[PrNR] + (ShM >> 3); if ((ShM & e) == ShM) break; }

            tS1 = S_1Ptr[c]; tS2 = S_2Ptr[c]; tS3 = S_3Ptr[c]; tS4 = S_4Ptr[c];
            i = 0;
            while (i < BS)
            {
                g = temp_bufferPtr[i];
                e = ((tS1 >> 8) * HEVAG_1 + (tS2 >> 8) * HEVAG_2 +
                     (tS3 >> 8) * HEVAG_3 + (tS4 >> 8) * HEVAG_4) >> 5;
                e = g - e;

                d1 = e << ShF;
                d0 = (d1 + 0x80000) >> 20;
                if (d0 >  7) d0 =  7;
                if (d0 < -8) d0 = -8;
                four_bitPtr[i] = d0 & 0xF;
                d0 <<= 20 - ShF;

                tS4 = tS3; tS3 = tS2; tS2 = tS1; tS1 = d0 - e;
                i++;
            }
        }