The-Homebrew-Cloud/customizemii
2
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
c276e85f01
customizemii/CustomizeMii/BNS.cs

715 lines
28 KiB
C#
Raw Normal View History

CustomizeMii 2.0 git-svn-id: svn://localhost/Users/andi/Downloads/code/trunk@12 eddbe33b-e435-4246-ac25-f5eb65f9a13c
2009-12-22 00:58:53 +01:00
/* This file is part of CustomizeMii
* Copyright (C) 2009 Leathl
*
* CustomizeMii is free software: you can redistribute it and/or
* modify it under the terms of the GNU General Public License as published
* by the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* CustomizeMii is distributed in the hope that it will be
* useful, but WITHOUT ANY WARRANTY; without even the implied warranty
* of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
//These classes are based on bns.py of the Wii.py Framework with improvements by me (Leathl)
//Thanks to Xuzz, SquidMan, megazig, Matt_P, Omega and The Lemon Man, the authors of Wii.py!
using System;
using System.Collections.Generic;
using System.IO;
using WaveFile;
namespace BNS
{
internal class BNS_Data
{
//Private Varialbes
private byte[] magic = new byte[] { (byte)'D', (byte)'A', (byte)'T', (byte)'A' };
private UInt32 size = 0x0004d000;
private byte[] data;
//Public Variables
public UInt32 Size { get { return size; } set { size = value; } }
public byte[] Data { get { return data; } set { data = value; } }
public BNS_Data() { }
public void Write(Stream outStream)
{
byte[] temp = BitConverter.GetBytes(size); Array.Reverse(temp);
outStream.Write(magic, 0, magic.Length);
outStream.Write(temp, 0, temp.Length);
outStream.Write(data, 0, data.Length);
}
}
internal class BNS_Info
{
//Private Variables
private byte[] magic = new byte[] { (byte)'I', (byte)'N', (byte)'F', (byte)'O' };
private UInt32 size = 0x000000a0;
private byte codec = 0x00;
private byte hasLoop = 0x00;
private byte channelCount = 0x02;
private byte zero = 0x00;
private UInt16 sampleRate = 0xac44;
private UInt16 pad0 = 0x0000;
private UInt32 loopStart = 0x00000000;
private UInt32 loopEnd = 0x00000000; //Or total sample count
private UInt32 offsetToChannelStart = 0x00000018;
private UInt32 pad1 = 0x00000000;
private UInt32 channel1StartOffset = 0x00000020;
private UInt32 channel2StartOffset = 0x0000002C;
private UInt32 channel1Start = 0x00000000;
private UInt32 coefficients1Offset = 0x0000038;
private UInt32 pad2 = 0x00000000;
private UInt32 channel2Start = 0x00000000;
private UInt32 coefficients2Offset = 0x00000068;
private UInt32 pad3 = 0x00000000;
private int[] coefficients1 = new int[16];
private UInt16 channel1Gain = 0x0000;
private UInt16 channel1PredictiveScale = 0x0000;
private UInt16 channel1PreviousValue = 0x0000;
private UInt16 channel1NextPreviousValue = 0x0000;
private UInt16 channel1LoopPredictiveScale = 0x0000;
private UInt16 channel1LoopPreviousValue = 0x0000;
private UInt16 channel1LoopNextPreviousValue = 0x0000;
private UInt16 channel1LoopPadding = 0x0000;
private int[] coefficients2 = new int[16];
private UInt16 channel2Gain = 0x0000;
private UInt16 channel2PredictiveScale = 0x0000;
private UInt16 channel2PreviousValue = 0x0000;
private UInt16 channel2NextPreviousValue = 0x0000;
private UInt16 channel2LoopPredictiveScale = 0x0000;
private UInt16 channel2LoopPreviousValue = 0x0000;
private UInt16 channel2LoopNextPreviousValue = 0x0000;
private UInt16 channel2LoopPadding = 0x0000;
//Public Variables
public byte HasLoop { get { return hasLoop; } set { hasLoop = value; } }
public UInt32 Coefficients1Offset { get { return coefficients1Offset; } set { coefficients1Offset = value; } }
public UInt32 Channel1StartOffset { get { return channel1StartOffset; } set { channel1StartOffset = value; } }
public UInt32 Channel2StartOffset { get { return channel2StartOffset; } set { channel2StartOffset = value; } }
public UInt32 Size { get { return size; } set { size = value; } }
public UInt16 SampleRate { get { return sampleRate; } set { sampleRate = value; } }
public byte ChannelCount { get { return channelCount; } set { channelCount = value; } }
public UInt32 Channel1Start { get { return channel1Start; } set { channel1Start = value; } }
public UInt32 Channel2Start { get { return channel2Start; } set { channel2Start = value; } }
public UInt32 LoopStart { get { return loopStart; } set { loopStart = value; } }
public UInt32 LoopEnd { get { return loopEnd; } set { loopEnd = value; } }
public int[] Coefficients1 { get { return coefficients1; } set { coefficients1 = value; } }
public int[] Coefficients2 { get { return coefficients2; } set { coefficients2 = value; } }
public BNS_Info() { }
public void Write(Stream outStream)
{
outStream.Write(magic, 0, magic.Length);
byte[] temp = BitConverter.GetBytes(size); Array.Reverse(temp);
outStream.Write(temp, 0, temp.Length);
outStream.WriteByte(codec);
outStream.WriteByte(hasLoop);
outStream.WriteByte(channelCount);
outStream.WriteByte(zero);
temp = BitConverter.GetBytes(sampleRate); Array.Reverse(temp);
outStream.Write(temp, 0, temp.Length);
temp = BitConverter.GetBytes(pad0); Array.Reverse(temp);
outStream.Write(temp, 0, temp.Length);
temp = BitConverter.GetBytes(loopStart); Array.Reverse(temp);
outStream.Write(temp, 0, temp.Length);
temp = BitConverter.GetBytes(loopEnd); Array.Reverse(temp);
outStream.Write(temp, 0, temp.Length);
temp = BitConverter.GetBytes(offsetToChannelStart); Array.Reverse(temp);
outStream.Write(temp, 0, temp.Length);
temp = BitConverter.GetBytes(pad1); Array.Reverse(temp);
outStream.Write(temp, 0, temp.Length);
temp = BitConverter.GetBytes(channel1StartOffset); Array.Reverse(temp);
outStream.Write(temp, 0, temp.Length);
temp = BitConverter.GetBytes(channel2StartOffset); Array.Reverse(temp);
outStream.Write(temp, 0, temp.Length);
temp = BitConverter.GetBytes(channel1Start); Array.Reverse(temp);
outStream.Write(temp, 0, temp.Length);
temp = BitConverter.GetBytes(coefficients1Offset); Array.Reverse(temp);
outStream.Write(temp, 0, temp.Length);
if (this.channelCount == 2)
{
temp = BitConverter.GetBytes(pad2); Array.Reverse(temp);
outStream.Write(temp, 0, temp.Length);
temp = BitConverter.GetBytes(channel2Start); Array.Reverse(temp);
outStream.Write(temp, 0, temp.Length);
temp = BitConverter.GetBytes(coefficients2Offset); Array.Reverse(temp);
outStream.Write(temp, 0, temp.Length);
temp = BitConverter.GetBytes(pad3); Array.Reverse(temp);
outStream.Write(temp, 0, temp.Length);
foreach (int thisInt in coefficients1)
{
temp = BitConverter.GetBytes(thisInt); Array.Reverse(temp);
outStream.Write(temp, 2, temp.Length - 2);
}
temp = BitConverter.GetBytes(channel1Gain); Array.Reverse(temp);
outStream.Write(temp, 0, temp.Length);
temp = BitConverter.GetBytes(channel1PredictiveScale); Array.Reverse(temp);
outStream.Write(temp, 0, temp.Length);
temp = BitConverter.GetBytes(channel1PreviousValue); Array.Reverse(temp);
outStream.Write(temp, 0, temp.Length);
temp = BitConverter.GetBytes(channel1NextPreviousValue); Array.Reverse(temp);
outStream.Write(temp, 0, temp.Length);
temp = BitConverter.GetBytes(channel1LoopPredictiveScale); Array.Reverse(temp);
outStream.Write(temp, 0, temp.Length);
temp = BitConverter.GetBytes(channel1LoopPreviousValue); Array.Reverse(temp);
outStream.Write(temp, 0, temp.Length);
temp = BitConverter.GetBytes(channel1LoopNextPreviousValue); Array.Reverse(temp);
outStream.Write(temp, 0, temp.Length);
temp = BitConverter.GetBytes(channel1LoopPadding); Array.Reverse(temp);
outStream.Write(temp, 0, temp.Length);
foreach (int thisInt in coefficients2)
{
temp = BitConverter.GetBytes(thisInt); Array.Reverse(temp);
outStream.Write(temp, 2, temp.Length - 2);
}
temp = BitConverter.GetBytes(channel2Gain); Array.Reverse(temp);
outStream.Write(temp, 0, temp.Length);
temp = BitConverter.GetBytes(channel2PredictiveScale); Array.Reverse(temp);
outStream.Write(temp, 0, temp.Length);
temp = BitConverter.GetBytes(channel2PreviousValue); Array.Reverse(temp);
outStream.Write(temp, 0, temp.Length);
temp = BitConverter.GetBytes(channel2NextPreviousValue); Array.Reverse(temp);
outStream.Write(temp, 0, temp.Length);
temp = BitConverter.GetBytes(channel2LoopPredictiveScale); Array.Reverse(temp);
outStream.Write(temp, 0, temp.Length);
temp = BitConverter.GetBytes(channel2LoopPreviousValue); Array.Reverse(temp);
outStream.Write(temp, 0, temp.Length);
temp = BitConverter.GetBytes(channel2LoopNextPreviousValue); Array.Reverse(temp);
outStream.Write(temp, 0, temp.Length);
temp = BitConverter.GetBytes(channel2LoopPadding); Array.Reverse(temp);
outStream.Write(temp, 0, temp.Length);
}
else if (this.channelCount == 1)
{
foreach (int thisInt in coefficients1)
{
temp = BitConverter.GetBytes(thisInt); Array.Reverse(temp);
outStream.Write(temp, 2, temp.Length - 2);
}
temp = BitConverter.GetBytes(channel1Gain); Array.Reverse(temp);
outStream.Write(temp, 0, temp.Length);
temp = BitConverter.GetBytes(channel1PredictiveScale); Array.Reverse(temp);
outStream.Write(temp, 0, temp.Length);
temp = BitConverter.GetBytes(channel1PreviousValue); Array.Reverse(temp);
outStream.Write(temp, 0, temp.Length);
temp = BitConverter.GetBytes(channel1NextPreviousValue); Array.Reverse(temp);
outStream.Write(temp, 0, temp.Length);
temp = BitConverter.GetBytes(channel1LoopPredictiveScale); Array.Reverse(temp);
outStream.Write(temp, 0, temp.Length);
temp = BitConverter.GetBytes(channel1LoopPreviousValue); Array.Reverse(temp);
outStream.Write(temp, 0, temp.Length);
temp = BitConverter.GetBytes(channel1LoopNextPreviousValue); Array.Reverse(temp);
outStream.Write(temp, 0, temp.Length);
temp = BitConverter.GetBytes(channel1LoopPadding); Array.Reverse(temp);
outStream.Write(temp, 0, temp.Length);
}
}
}
internal class BNS_Header
{
//Private Variables
private byte[] magic = new byte[] { (byte)'B', (byte)'N', (byte)'S', (byte)' ' };
private UInt32 flags = 0xfeff0100;
private UInt32 fileSize = 0x0004d0c0;
private UInt16 size = 0x0020;
private UInt16 chunkCount = 0x0002;
private UInt32 infoOffset = 0x00000020;
private UInt32 infoLength = 0x000000a0;
private UInt32 dataOffset = 0x000000c0;
private UInt32 dataLength = 0x0004d000;
//Public Varialbes
public UInt32 DataOffset { get { return dataOffset; } set { dataOffset = value; } }
public UInt32 InfoLength { get { return infoLength; } set { infoLength = value; } }
public UInt16 Size { get { return size; } set { size = value; } }
public UInt32 DataLength { get { return dataLength; } set { dataLength = value; } }
public UInt32 FileSize { get { return fileSize; } set { fileSize = value; } }
public BNS_Header() { }
public void Write(Stream outStream)
{
outStream.Write(magic, 0, magic.Length);
byte[] temp = BitConverter.GetBytes(flags); Array.Reverse(temp);
outStream.Write(temp, 0, temp.Length);
temp = BitConverter.GetBytes(fileSize); Array.Reverse(temp);
outStream.Write(temp, 0, temp.Length);
temp = BitConverter.GetBytes(size); Array.Reverse(temp);
outStream.Write(temp, 0, temp.Length);
temp = BitConverter.GetBytes(chunkCount); Array.Reverse(temp);
outStream.Write(temp, 0, temp.Length);
temp = BitConverter.GetBytes(infoOffset); Array.Reverse(temp);
outStream.Write(temp, 0, temp.Length);
temp = BitConverter.GetBytes(infoLength); Array.Reverse(temp);
outStream.Write(temp, 0, temp.Length);
temp = BitConverter.GetBytes(dataOffset); Array.Reverse(temp);
outStream.Write(temp, 0, temp.Length);
temp = BitConverter.GetBytes(dataLength); Array.Reverse(temp);
outStream.Write(temp, 0, temp.Length);
}
}
public class BNS_File
{
//Private Variables
private BNS_Header bnsHeader = new BNS_Header();
private BNS_Info bnsInfo = new BNS_Info();
private BNS_Data bnsData = new BNS_Data();
private int[,] lSamples = new int[2, 2];
private int[,] rlSamples = new int[2, 2];
private int[] tlSamples = new int[2];
private int[] hbcDefTbl = new int[] { 674, 1040, 3598, -1738, 2270, -583, 3967, -1969, 1516, 381, 3453, -1468, 2606, -617, 3795, -1759 };
private int[] defTbl = new int[] { 1820, -856, 3238, -1514, 2333, -550, 3336, -1376, 2444, -949, 3666, -1764, 2654, -701, 3420, -1398 };
private int[] pHist1 = new int[2];
private int[] pHist2 = new int[2];
private int tempSampleCount;
private string waveFile;
private bool loopFromWave = false;
private bool converted = false;
private bool toMono = false;
//Public Variables
/// <summary>
/// 0x00 (0) = No Loop, 0x01 (1) = Loop
/// </summary>
public byte HasLoop { get { return this.bnsInfo.HasLoop; } set { this.bnsInfo.HasLoop = value; } }
/// <summary>
/// The start sample of the Loop
/// </summary>
public UInt32 LoopStart { get { return this.bnsInfo.LoopStart; } set { this.bnsInfo.LoopStart = value; } }
/// <summary>
/// The total number of samples in this file
/// </summary>
public UInt32 TotalSampleCount { get { return this.bnsInfo.LoopEnd; } set { this.bnsInfo.LoopEnd = value; } }
/// <summary>
/// If true and the input Wave file is stereo, the BNS will be converted to Mono.
/// Be sure to set this before you call Convert()!
/// </summary>
public bool StereoToMono { get { return toMono; } set { toMono = value; } }
//Public Functions
public BNS_File(string waveFile)
{
this.waveFile = waveFile;
}
public BNS_File(string waveFile, bool loopFromWave)
{
this.waveFile = waveFile;
this.loopFromWave = loopFromWave;
}
/// <summary>
/// Returns the progress of the conversion
/// </summary>
public event EventHandler<System.ComponentModel.ProgressChangedEventArgs> ProgressChanged;
/// <summary>
/// Converts the Wave file to BNS
/// </summary>
public void Convert()
{
Convert(waveFile, loopFromWave);
}
/// <summary>
/// Returns the BNS file as a Byte Array. If not already converted, it will be done first.
/// </summary>
/// <returns></returns>
public byte[] ToByteArray()
{
return ToMemoryStream().ToArray();
}
/// <summary>
/// Returns the BNS file as a Memory Stream. If not already converted, it will be done first.
/// </summary>
/// <returns></returns>
public MemoryStream ToMemoryStream()
{
if (!converted)
Convert(waveFile, loopFromWave);
MemoryStream ms = new MemoryStream();
this.bnsHeader.Write(ms);
this.bnsInfo.Write(ms);
this.bnsData.Write(ms);
return ms;
}
/// <summary>
/// Saves the BNS file to the given path. If not already converted, it will be done first.
/// </summary>
/// <param name="destionationFile"></param>
public void Save(string destionationFile)
{
if (File.Exists(destionationFile)) File.Delete(destionationFile);
using (FileStream fs = new FileStream(destionationFile, FileMode.Create))
{
byte[] bnsFile = ToMemoryStream().ToArray();
fs.Write(bnsFile, 0, bnsFile.Length);
}
}
/// <summary>
/// Sets the Loop to the given Start Sample. Be sure that you call Convert() first!
/// </summary>
/// <param name="loopStartSample"></param>
public void SetLoop(int loopStartSample)
{
this.bnsInfo.HasLoop = 0x01;
this.bnsInfo.LoopStart = (uint)loopStartSample;
}
//Private Functions
private void Convert(string waveFile, bool loopFromWave)
{
Wave wave = new Wave(waveFile);
int waveLoopCount = wave.LoopCount;
int waveLoopStart = wave.LoopStart;
this.bnsInfo.ChannelCount = (byte)wave.ChannelCount;
this.bnsInfo.SampleRate = (ushort)wave.SampleRate;
if (this.bnsInfo.ChannelCount > 2 || this.bnsInfo.ChannelCount < 1)
throw new Exception("Unsupported Count of Channels!");
if (wave.BitDepth != 16)
throw new Exception("Only 16bit Wave files are supported!");
if (wave.DataFormat != 1)
throw new Exception("The format of this Wave file is not supported!");
this.bnsData.Data = Encode(wave.GetAllFrames());
wave.Close();
if (this.bnsInfo.ChannelCount == 1)
{
this.bnsHeader.InfoLength = 0x60;
this.bnsHeader.DataOffset = 0x80;
this.bnsInfo.Size = 0x60;
this.bnsInfo.Channel1StartOffset = 0x0000001C;
this.bnsInfo.Channel2StartOffset = 0x00000000;
this.bnsInfo.Channel1Start = 0x00000028;
this.bnsInfo.Coefficients1Offset = 0x00000000;
}
this.bnsData.Size = (uint)bnsData.Data.Length + 8;
this.bnsHeader.DataLength = this.bnsData.Size;
this.bnsHeader.FileSize = this.bnsHeader.Size + this.bnsInfo.Size + this.bnsData.Size;
if (loopFromWave)
if (waveLoopCount == 1)
if (waveLoopStart != -1)
{ this.bnsInfo.LoopStart = (uint)waveLoopStart; this.bnsInfo.HasLoop = 0x01; }
this.bnsInfo.LoopEnd = (uint)tempSampleCount;
for (int i = 0; i < 16; i++)
{
this.bnsInfo.Coefficients1[i] = this.defTbl[i];
if (this.bnsInfo.ChannelCount == 2)
this.bnsInfo.Coefficients2[i] = this.defTbl[i];
}
this.converted = true;
}
private byte[] Encode(byte[] inputFrames)
{
int offset = 0;
int[] sampleBuffer = new int[14];
this.tempSampleCount = inputFrames.Length / (bnsInfo.ChannelCount == 2 ? 4 : 2);
int modLength = (inputFrames.Length / (bnsInfo.ChannelCount == 2 ? 4 : 2)) % 14;
Array.Resize(ref inputFrames, inputFrames.Length + ((14 - modLength) * (bnsInfo.ChannelCount == 2 ? 4 : 2)));
int sampleCount = inputFrames.Length / (bnsInfo.ChannelCount == 2 ? 4 : 2);
int blocks = (sampleCount + 13) / 14;
List<int> soundDataLeft = new List<int>();
List<int> soundDataRight = new List<int>();
int co = offset;
if (this.toMono && this.bnsInfo.ChannelCount == 2) this.bnsInfo.ChannelCount = 1;
else if (this.toMono) this.toMono = false;
for (int j = 0; j < sampleCount; j++)
{
soundDataLeft.Add(BitConverter.ToInt16(inputFrames, co));
co += 2;
if (this.bnsInfo.ChannelCount == 2 || toMono)
{
soundDataRight.Add(BitConverter.ToInt16(inputFrames, co));
co += 2;
}
}
byte[] data = new byte[(this.bnsInfo.ChannelCount == 2 ? (blocks * 16) : (blocks * 8))];
int data1Offset = 0;
int data2Offset = blocks * 8;
this.bnsInfo.Channel2Start = (this.bnsInfo.ChannelCount == 2 ? (uint)data2Offset : 0);
int[] leftSoundData = soundDataLeft.ToArray();
int[] rightSoundData = soundDataRight.ToArray();
for (int y = 0; y < blocks; y++)
{
try
{
if (y % (int)(blocks / 100) == 0 || (y + 1) == blocks)
ChangeProgress((y + 1) * 100 / blocks);
}
catch { }
for (int a = 0; a < 14; a++)
sampleBuffer[a] = leftSoundData[y * 14 + a];
byte[] outBuffer = RepackAdpcm(0, this.defTbl, sampleBuffer);
for (int a = 0; a < 8; a++)
data[data1Offset + a] = outBuffer[a];
data1Offset += 8;
if (this.bnsInfo.ChannelCount == 2)
{
for (int a = 0; a < 14; a++)
sampleBuffer[a] = rightSoundData[y * 14 + a];
outBuffer = RepackAdpcm(1, this.defTbl, sampleBuffer);
for (int a = 0; a < 8; a++)
data[data2Offset + a] = outBuffer[a];
data2Offset += 8;
}
}
this.bnsInfo.LoopEnd = (uint)(blocks * 7);
return data;
}
private byte[] RepackAdpcm(int index, int[] table, int[] inputBuffer)
{
byte[] data = new byte[8];
int[] blSamples = new int[2];
int bestIndex = -1;
double bestError = 999999999.0;
double error;
for (int tableIndex = 0; tableIndex < 8; tableIndex++)
{
byte[] testData = CompressAdpcm(index, table, tableIndex, inputBuffer, out error);
if (error < bestError)
{
bestError = error;
for (int i = 0; i < 8; i++)
data[i] = testData[i];
for (int i = 0; i < 2; i++)
blSamples[i] = this.tlSamples[i];
bestIndex = tableIndex;
}
}
for (int i = 0; i < 2; i++)
this.rlSamples[index, i] = blSamples[i];
return data;
}
private byte[] CompressAdpcm(int index, int[] table, int tableIndex, int[] inputBuffer, out double outError)
{
byte[] data = new byte[8];
int error = 0;
int factor1 = table[2 * tableIndex + 0];
int factor2 = table[2 * tableIndex + 1];
int exponent = DetermineStdExponent(index, table, tableIndex, inputBuffer);
while (exponent <= 15)
{
bool breakIt = false;
error = 0;
data[0] = (byte)(exponent | (tableIndex << 4));
for (int i = 0; i < 2; i++)
this.tlSamples[i] = this.rlSamples[index, i];
int j = 0;
for (int i = 0; i < 14; i++)
{
int predictor = (int)((this.tlSamples[1] * factor1 + this.tlSamples[0] * factor2) >> 11);
int residual = (inputBuffer[i] - predictor) >> exponent;
if (residual > 7 || residual < -8)
{
exponent++;
breakIt = true;
break;
}
int nibble = Clamp(residual, -8, 7);
if ((i & 1) != 0)
data[i / 2 + 1] = (byte)(data[i / 2 + 1] | (nibble & 0xf));
else
data[i / 2 + 1] = (byte)(nibble << 4);
predictor += nibble << exponent;
this.tlSamples[0] = this.tlSamples[1];
this.tlSamples[1] = Clamp(predictor, -32768, 32767);
error += (int)(Math.Pow((double)(this.tlSamples[1] - inputBuffer[i]), 2));
}
if (!breakIt) j = 14;
if (j == 14) break;
}
outError = error;
return data;
}
private int DetermineStdExponent(int index, int[] table, int tableIndex, int[] inputBuffer)
{
int[] elSamples = new int[2];
int maxResidual = 0;
int factor1 = table[2 * tableIndex + 0];
int factor2 = table[2 * tableIndex + 1];
for (int i = 0; i < 2; i++)
elSamples[i] = this.rlSamples[index, i];
for (int i = 0; i < 14; i++)
{
int predictor = (elSamples[1] * factor1 + elSamples[0] * factor2) >> 11;
int residual = inputBuffer[i] - predictor;
if (residual > maxResidual)
maxResidual = residual;
elSamples[0] = elSamples[1];
elSamples[1] = inputBuffer[i];
}
return FindExponent(maxResidual);
}
private int FindExponent(double residual)
{
int exponent = 0;
while (residual > 7.5 || residual < -8.5)
{
exponent++;
residual /= 2.0;
}
return exponent;
}
private int Clamp(int input, int min, int max)
{
if (input < min) return min;
if (input > max) return max;
return input;
}
private void ChangeProgress(int progressPercentage)
{
EventHandler<System.ComponentModel.ProgressChangedEventArgs> progressChanged = ProgressChanged;
if (progressChanged != null)
{
progressChanged(new object(), new System.ComponentModel.ProgressChangedEventArgs(progressPercentage, new object()));
}
}
}
}
Reference in New Issue Copy Permalink