示例#1
0
        /// <summary>
        /// Loads a *.utk file, setting things up for decompression.
        /// Should always be called before DecompressFile().
        /// </summary>
        /// <param name="Path">The path to the *.utk file to load.</param>
        public void LoadFile(string Path)
        {
            m_Reader = new BinaryReader(File.Open(Path, FileMode.Open));

            m_ID = new string(m_Reader.ReadChars(4));
            m_DecompressedSize = m_Reader.ReadUInt32();
            m_WaveFormatXSize = m_Reader.ReadUInt32();
            m_FormatTag = m_Reader.ReadUInt16();
            m_NumChannels = m_Reader.ReadUInt16();
            m_SamplesPerSec = m_Reader.ReadUInt32();
            m_AvgBytesPerSec = m_Reader.ReadUInt32();
            m_BlockAlign = m_Reader.ReadUInt16();
            m_BitsPerSample = m_Reader.ReadUInt16();
            m_AppendSize = m_Reader.ReadUInt32();

            m_DecompressedStream = new MemoryStream();
            m_Writer = new BinaryWriter(m_DecompressedStream);

            //Write wav-header.
            uint dwDataSize = m_DecompressedSize;
            uint dwFMTSize = 16;
            uint dwRIFFSize = 36 + dwDataSize;

            m_Writer.Write(new char[] { 'R', 'I', 'F', 'F' });
            m_Writer.Write(dwRIFFSize); //Size of file minus this field and the above field.
            m_Writer.Write(new char[] { 'W', 'A', 'V', 'E', 'f', 'm', 't', ' ' });
            m_Writer.Write(dwFMTSize); //Size of WAVEFORMATEX structure (all the data that comes after this field).
            m_Writer.Write(m_FormatTag);
            m_Writer.Write(m_NumChannels);
            m_Writer.Write(m_SamplesPerSec);
            m_Writer.Write(m_AvgBytesPerSec);
            m_Writer.Write(m_BlockAlign);
            m_Writer.Write(m_BitsPerSample);
            m_Writer.Write(new char[] { 'd', 'a', 't', 'a' });
            m_Writer.Write(dwDataSize);

            UTKParams P = new UTKParams();
            P.UnreadBitsValue = m_Reader.ReadByte();
            P.UnreadBitsCount = 8;

            P.UseLattice = (int)ReadBits(P, 1);
            P.NoiseFloor = (uint)32 - ReadBits(P, 4);
            P.FixedCodeBook[0] = (ReadBits(P, 4) + 1) * 8;

            float S = (float)ReadBits(P, 6) / 1000 + 1.04f;

            for (int i = 1; i < 64; i++)
                P.FixedCodeBook[i] = P.FixedCodeBook[i - 1] * S;

            //memset(p->ImpulseTrain, 0, 12*sizeof(float));
            Array.Clear(P.ImpulseTrain, 0, 12);

            //memset(p->R, 0, 12*sizeof(float));
            Array.Clear(P.R, 0, 12);

            //memset(p->Delay, 0, 324*sizeof(float));
            Array.Clear(P.Delay, 0, 324);

            uint Frames = (uint)(m_DecompressedSize / m_BlockAlign);

            UTKDecode(P, Frames);
        }
示例#2
0
        private void UTKDecode(UTKParams P, uint Frames)
        {
            while (Frames > 0)
            {
                uint BlockSize = (Frames > 432) ? 432 : Frames;
                DecompressBlock(ref P);

                for (uint i = 0; i < BlockSize; i++)
                {
                    int value = Round(P.DecompressedBlock[i]);

                    if (value < -32767)
                        value = 32767;
                    else if (value > 32768)
                        value = 32768;

                    //Writing out as byte seems to fix the filesize.
                    m_Writer.Write((byte)((value & 0x00FF/*u*/) >> (8 * 0)));
                    m_Writer.Write((byte)((value & 0xFF00/*u*/) >> (8 * 1)));
                }

                Frames -= BlockSize;
            }
        }
示例#3
0
        private unsafe void Synthesize(UTKParams P, int Sample, uint Blocks)
        {
            float[] Residual = new float[12];
            uint Samples = Blocks*12;
            int offset = -1;

            fixed (float* C64 = &P.ImpulseTrain[0])
            {
                PredictionFilter(C64, ref Residual);
            }

            while(Samples > 0)
            {
                Samples--;

                float x = P.DecompressedBlock[Sample];

                for (int i = 0; i < 12; i++)
                {
                    if (++offset == 12) offset = 0;
                    x += P.R[offset] * Residual[i];
                }

                P.R[offset--] = x;
                P.DecompressedBlock[Sample++] = x;
            }
        }
示例#4
0
        private byte ReadBits(UTKParams P, byte NumBits)
        {
            byte ReturnValue = (byte)((255 >> (8 - NumBits)) & P.UnreadBitsValue);
            P.UnreadBitsValue >>= NumBits;
            P.UnreadBitsCount -= NumBits;

            try
            {
                if (P.UnreadBitsCount < 8)
                {
                    uint Value = (byte)m_Reader.ReadByte();
                    P.UnreadBitsValue |= (byte)(Value << P.UnreadBitsCount/* & 0xFF*/);
                    P.UnreadBitsCount += 8;
                }
            }
            catch (EndOfStreamException)
            {
                return ReturnValue;
            }

            return ReturnValue;
        }
示例#5
0
        private unsafe void LatticeFilter(ref UTKParams P, int Voiced, float* Window, int Interval)
        {
            if (Voiced != 0)
            {
                int t = 0;
                int i = 0;

                while (i < 108)
                {
                    uint code = m_UTKTable2[(t << 8) | (P.UnreadBitsValue & 0xFF)];

                    t = (code < 2 || code > 8) ? 1 : 0;

                    ReadBits(P, m_UTKTable3[code]);

                    if (code >= 4)
                    {
                        Window[i] = m_UTKTable4[code];
                        i += Interval;
                    }
                    else
                    {
                        if (code > 1)
                        {
                            int x = (int)ReadBits(P, 6) + 7;
                            if (x > (108 - i) / Interval)
                                x = (108 - i) / Interval;

                            while(x > 0)
                            {
                                x--;
                                Window[i] = 0;
                                i += Interval;
                            }
                        }
                        else
                        {
                            Window[i] = 7;
                            while (ReadBits(P, 1) > 0)
                                Window[i]++;

                            if (ReadBits(P, 1) != 0)
                                Window[i] *= -1;

                            i += Interval;
                        }
                    }
                }
            }
            else
            {
                //Unvoiced signal; load noise
                int i;
                for (i = 0; i < 108; i += Interval)
                {
                    byte b;

                    switch (P.UnreadBitsValue & 3)
                    {
                        case 3:
                            Window[i] = 2.0f;
                            b = 2;
                            break;
                        case 1:
                            Window[i] = -2.0f;
                            b = 2;
                            break;
                        default:
                            Window[i] = 0.0f;
                            b = 1;
                            break;
                    }

                    ReadBits(P, b);
                }
            }
        }
示例#6
0
        private unsafe void DecompressBlock(ref UTKParams P)
        {
            float[] Window = new float[118];
            float[] Matrix = new float[12];
            int Voiced = 0;

            //memset(&Window[0], 0, 5*sizeof(float));
            Array.Clear(Window, 0, 5);

            //memset(&Window[113], 0, 5 * sizeof(float));
            Array.Clear(Window, 113, 5);

            for (int i = 0; i < 12; i++)
            {
                uint result = ReadBits(P, (byte)((i < 4) ? 6 : 5));
                if (i == 0 && P.NoiseFloor > result) Voiced++;
                Matrix[i] = (m_UTKTable1[result + ((i < 4) ? 0 : 16)] - P.ImpulseTrain[i]) / 4;
            }

            for (int i = 0; i < 4; i++)
            {
                float PitchGain, InnovationGain;
                int Phase = (int)ReadBits(P, 8);
                PitchGain = ((float)ReadBits(P, 4)) / 15;
                InnovationGain = P.FixedCodeBook[ReadBits(P, 6)];

                if (P.UseLattice == 0)
                {
                    fixed (float* Wnd = &Window[5])
                    {
                        LatticeFilter(ref P, Voiced, Wnd, 1);
                    }
                }
                else
                {
                    int o = ReadBits(P, 1); //Order
                    int y = ReadBits(P, 1);

                    fixed (float* Wnd = &Window[5 + o])
                    {
                        LatticeFilter(ref P, Voiced, Wnd, 2);
                    }

                    if (y != 0)
                    {
                        for (int j = 0; j < 108; j += 2)
                            Window[6 - o + j] = 0;
                    }
                    else
                    {
                        //Vector quantization
                        fixed (float* Wnd = &Window[6 - o])
                        {
                            float* Z = Wnd;
                            for (int j = 0; j < 54; j++, Z += 2)
                                *Z =
                                      (Z[-5] + Z[+5]) * .0180326793f
                                    - (Z[-3] + Z[+3]) * .1145915613f
                                    + (Z[-1] + Z[+1]) * .5973859429f;

                            InnovationGain /= 2;
                        }
                    }
                }

                //Excitation
                for (int j = 0; j < 108; j++)
                {
                    try
                    {
                        P.DecompressedBlock[108 * i + j] = InnovationGain * Window[5 + j] + PitchGain * P.Delay[216 - Phase + 108 * i + j];
                    }
                    catch (IndexOutOfRangeException)
                    {
                        break;
                    }
                }
            }

            //Not sure about the last part of this statement...
            Array.Copy(P.Delay, 0, P.DecompressedBlock, 108, 324 /** sizeof(uint)*/);

            for (int i = 0; i < 4; i++)
            {
                for (int j = 0; j < 12; j++)
                    P.ImpulseTrain[j] += Matrix[j];

                Synthesize(P, i * 12, (uint)((i != 3) ? 1 : 33));
            }
        }