示例#1
0
 protected void unpInitData20(bool Solid)
 {
     if (!Solid)
     {
         UnpChannelDelta = UnpCurChannel = 0;
         UnpChannels     = 1;
         // memset(AudV,0,sizeof(AudV));
         AudV[0] = new AudioVariables();
         AudV[1] = new AudioVariables();
         AudV[2] = new AudioVariables();
         AudV[3] = new AudioVariables();
         // memset(UnpOldTable20,0,sizeof(UnpOldTable20));
         Utility.Fill(UnpOldTable20, (byte)0);
     }
 }
示例#2
0
        private byte DecodeAudio(int Delta)
        {
            AudioVariables v = AudV[UnpCurChannel];

            v.ByteCount = v.ByteCount + 1;
            v.D4        = v.D3;
            v.D3        = v.D2;               // ->D3=V->D2;
            v.D2        = v.LastDelta - v.D1; // ->D2=V->LastDelta-V->D1;
            v.D1        = v.LastDelta;        // V->D1=V->LastDelta;
            // int PCh=8*V->LastChar+V->K1*V->D1 +V->K2*V->D2 +V->K3*V->D3
            // +V->K4*V->D4+ V->K5*UnpChannelDelta;
            int PCh = 8 * v.LastChar + v.K1 * v.D1;

            PCh += v.K2 * v.D2 + v.K3 * v.D3;
            PCh += v.K4 * v.D4 + v.K5 * UnpChannelDelta;
            PCh  = (Utility.URShift(PCh, 3)) & 0xFF;

            int Ch = PCh - Delta;

            int D = ((byte)Delta) << 3;

            v.Dif[0]  += System.Math.Abs(D);                   // V->Dif[0]+=abs(D);
            v.Dif[1]  += System.Math.Abs(D - v.D1);            // V->Dif[1]+=abs(D-V->D1);
            v.Dif[2]  += System.Math.Abs(D + v.D1);            // V->Dif[2]+=abs(D+V->D1);
            v.Dif[3]  += System.Math.Abs(D - v.D2);            // V->Dif[3]+=abs(D-V->D2);
            v.Dif[4]  += System.Math.Abs(D + v.D2);            // V->Dif[4]+=abs(D+V->D2);
            v.Dif[5]  += System.Math.Abs(D - v.D3);            // V->Dif[5]+=abs(D-V->D3);
            v.Dif[6]  += System.Math.Abs(D + v.D3);            // V->Dif[6]+=abs(D+V->D3);
            v.Dif[7]  += System.Math.Abs(D - v.D4);            // V->Dif[7]+=abs(D-V->D4);
            v.Dif[8]  += System.Math.Abs(D + v.D4);            // V->Dif[8]+=abs(D+V->D4);
            v.Dif[9]  += System.Math.Abs(D - UnpChannelDelta); // V->Dif[9]+=abs(D-UnpChannelDelta);
            v.Dif[10] += System.Math.Abs(D + UnpChannelDelta); // V->Dif[10]+=abs(D+UnpChannelDelta);

            v.LastDelta     = (byte)(Ch - v.LastChar);
            UnpChannelDelta = v.LastDelta;
            v.LastChar      = Ch; // V->LastChar=Ch;

            if ((v.ByteCount & 0x1F) == 0)
            {
                int MinDif = v.Dif[0], NumMinDif = 0;
                v.Dif[0] = 0; // ->Dif[0]=0;
                for (int I = 1; I < v.Dif.Length; I++)
                {
                    if (v.Dif[I] < MinDif)
                    {
                        MinDif    = v.Dif[I];
                        NumMinDif = I;
                    }
                    v.Dif[I] = 0;
                }
                switch (NumMinDif)
                {
                case 1:
                    if (v.K1 >= -16)
                    {
                        v.K1 = v.K1 - 1;     // V->K1--;
                    }
                    break;

                case 2:
                    if (v.K1 < 16)
                    {
                        v.K1 = v.K1 + 1;     // V->K1++;
                    }
                    break;

                case 3:
                    if (v.K2 >= -16)
                    {
                        v.K2 = v.K2 - 1;     // V->K2--;
                    }
                    break;

                case 4:
                    if (v.K2 < 16)
                    {
                        v.K2 = v.K2 + 1;     // V->K2++;
                    }
                    break;

                case 5:
                    if (v.K3 >= -16)
                    {
                        v.K3 = v.K3 - 1;
                    }
                    break;

                case 6:
                    if (v.K3 < 16)
                    {
                        v.K3 = v.K3 + 1;
                    }
                    break;

                case 7:
                    if (v.K4 >= -16)
                    {
                        v.K4 = v.K4 - 1;
                    }
                    break;

                case 8:
                    if (v.K4 < 16)
                    {
                        v.K4 = v.K4 + 1;
                    }
                    break;

                case 9:
                    if (v.K5 >= -16)
                    {
                        v.K5 = v.K5 - 1;
                    }
                    break;

                case 10:
                    if (v.K5 < 16)
                    {
                        v.K5 = v.K5 + 1;
                    }
                    break;
                }
            }
            return((byte)Ch);
        }