BrawlLib.Wii.Audio.AudioConverter Class Reference

Static Public Member Functions
static void	CalcCoefs (short *source, int samples, short *dest, IProgressTracker progress)
static void	EncodeBlock (short *source, int samples, byte *dest, short *coefs)

Member Function Documentation

CalcCoefs()

static void BrawlLib.Wii.Audio.AudioConverter.CalcCoefs ( short *  source, int  samples, short *  dest, IProgressTracker  progress  )

inlinestatic

        {
            //short[,] coefs = new short[8,2];
 
            //double d10 = 10.0;
            //int channels = 2;
            //int num2 = 2;
            //int chunkSamples = 14;
            //int var30 = 0;
            short* sPtr = source;
            int numBlocks = (samples + 13) / 14;
 
            int nBits = 3;
            //while ((1 << ++nBits) < 8) ;
 
            double** bufferArray = stackalloc double*[8];
            for (int z = 0; z < 8; z++)
            {
                bufferArray[z] = (double*) Marshal.AllocHGlobal(3 * 8);
            }
 
            double* buffer2 = stackalloc double[3];
            short* sampleBuffer = (short*) Marshal.AllocHGlobal(0x7000);
            short* chunkBuffer = stackalloc short[28];
            //double** chunkBuffer = (double**)chunkBufferData;
            for (int z = 0; z < 28; z++)
            {
                chunkBuffer[z] = 0;
            }
 
            double* sChunkBuffer = stackalloc double[3];
            double* omgBuffer = stackalloc double[3];
 
            double** pChannels = stackalloc double*[3];
            for (int z = 0; z <= 2; z++)
            {
                pChannels[z] = (double*) Marshal.AllocHGlobal(3 * 8);
            }
 
            int* anotherBuffer = stackalloc int[3];
 
            double** multiBuffer = (double**) Marshal.AllocHGlobal(numBlocks * 4 * 2);
            int unused = 0;
            int multiIndex = 0;
 
            int blockSamples;
            int temp;
 
            float initValue = 0;
            int lastUpdate = 0;
            if (progress != null)
            {
                initValue = progress.CurrentValue;
            }
 
            for (int x = samples; x > 0;)
            {
                if (x > 0x3800)
                {
                    blockSamples = 0x3800;
                    x -= 0x3800;
                }
                else
                {
                    blockSamples = x;
                    for (int z = 0; z < 14 && z + blockSamples < 0x3800; z++)
                    {
                        sampleBuffer[blockSamples + z] = 0;
                    }
 
                    x = 0;
                }
 
                short* tPtr = sampleBuffer;
                for (int z = 0; z < blockSamples; z++)
                {
                    *tPtr++ = *sPtr++;
                }
 
                for (int i = 0; i < blockSamples;)
                {
                    for (int z = 0; z < 14; z++)
                    {
                        chunkBuffer[z] = chunkBuffer[z + 14];
                    }
 
                    for (int z = 0; z < 14; z++)
                    {
                        chunkBuffer[z + 14] = sampleBuffer[i++];
                    }
 
                    Something1(&chunkBuffer[14], sChunkBuffer);
                    if (Math.Abs(sChunkBuffer[0]) > 10.0)
                    {
                        Something2(&chunkBuffer[14], pChannels);
                        if (!Something3(pChannels, anotherBuffer, &temp))
                        {
                            Something4(pChannels, anotherBuffer, sChunkBuffer);
                            sChunkBuffer[0] = 1.0;
                            if (Something5(sChunkBuffer, omgBuffer) == 0)
                            {
                                multiBuffer[multiIndex] = (double*) Marshal.AllocHGlobal(3 * 8);
                                multiBuffer[multiIndex][0] = 1.0;
                                for (int z = 1; z <= 2; z++)
                                {
                                    if (omgBuffer[z] >= 1.0)
                                    {
                                        omgBuffer[z] = 0.9999999999;
                                    }
 
                                    if (omgBuffer[z] <= -1.0)
                                    {
                                        omgBuffer[z] = -0.9999999999;
                                    }
                                }
 
                                Something6(omgBuffer, multiBuffer[multiIndex]);
                                multiIndex++;
                            }
                        }
                    }
 
                    unused++;
                }
 
                if (progress != null)
                {
                    lastUpdate += blockSamples;
                    if (lastUpdate % 0x3800 == 0)
                    {
                        progress.Update(progress.CurrentValue + 0x3800);
                    }
                }
            }
 
            progress?.Update(initValue + samples);
 
            sChunkBuffer[0] = 1.0;
            for (int y = 1; y <= 2; y++)
            {
                sChunkBuffer[y] = 0.0;
            }
 
            for (int z = 0; z < multiIndex; z++)
            {
                Something7(multiBuffer[z], bufferArray[0]);
                for (int y = 1; y <= 2; y++)
                {
                    sChunkBuffer[y] = sChunkBuffer[y] + bufferArray[0][y];
                }
            }
 
            for (int y = 1; y <= 2; y++)
            {
                sChunkBuffer[y] /= multiIndex;
            }
 
            double tmp;
            Something8(sChunkBuffer, omgBuffer, bufferArray[0], &tmp);
            for (int y = 1; y <= 2; y++)
            {
                if (omgBuffer[y] >= 1.0)
                {
                    omgBuffer[y] = 0.9999999999;
                }
 
                if (omgBuffer[y] <= -1.0)
                {
                    omgBuffer[y] = -0.9999999999;
                }
            }
 
            Something6(omgBuffer, bufferArray[0]);
 
            for (int w = 0; w < nBits;)
            {
                //int mask = 1 << w;
                for (int z = 0; z <= 2; z++)
                {
                    buffer2[z] = 0.0;
                }
 
                buffer2[1] = -1.0;
                Something9(bufferArray, buffer2, 1 << w++, 0.01);
                //w++;
                Something10(bufferArray, 1 << w, multiBuffer, multiIndex, 0.0);
            }
 
            //Write output
            for (int z = 0; z < 8; z++)
            {
                for (int y = 0; y < 2; y++)
                {
                    double d = -bufferArray[z][y + 1] * 2048.0;
                    if (d > 0.0)
                    {
                        dest[(z << 1) + y] = d > 32767.0 ? (short) 32767 : (short) (d + 0.5);
                    }
                    else
                    {
                        dest[(z << 1) + y] = d < -32768.0 ? (short) -32768 : (short) (d - 0.5);
                    }
                }
            }
 
            //Free memory
            for (int i = 0; i < multiIndex; i++)
            {
                Marshal.FreeHGlobal((IntPtr) multiBuffer[i]);
            }
 
            Marshal.FreeHGlobal((IntPtr) multiBuffer);
 
            for (int i = 0; i <= 2; i++)
            {
                Marshal.FreeHGlobal((IntPtr) pChannels[i]);
            }
 
            for (int i = 0; i < 8; i++)
            {
                Marshal.FreeHGlobal((IntPtr) bufferArray[i]);
            }
 
            Marshal.FreeHGlobal((IntPtr) sampleBuffer);
 
            //return coefs;
        }

EncodeBlock()

static void BrawlLib.Wii.Audio.AudioConverter.EncodeBlock ( short *  source, int  samples, byte *  dest, short *  coefs  )

inlinestatic

        {
            for (int i = 0; i < samples; i += 14, source += 14, dest += 8)
            {
                EncodeChunk(source, Math.Min(samples - i, 14), dest, coefs);
            }
        }

---

The documentation for this class was generated from the following file:

• BrawlLib/Wii/Audio/AudioConverter.cs