public static float[] ConvertWav2FFTMag(string wavfile, string outfile)
{
WAVFile audioFile = new WAVFile();
String warning = audioFile.Open(wavfile, WAVFile.WAVFileMode.READ);
Complex[] indata = new Complex[MaxSamples];
int IterSamples = (audioFile.NumSamples < MaxSamples) ? audioFile.NumSamples : MaxSamples;
float[] indata_mag = null;
if (warning == "")
{
//short audioSample = 0;
for (int sampleNum = 0; sampleNum < IterSamples; ++sampleNum)
{
//audioSample = audioFile.GetNextSampleAs16Bit();
indata[sampleNum].Re = audioFile.GetNextSampleAs16Bit();
}
FourierTransform.FFT(indata, FourierTransform.Direction.Forward);
indata_mag = GetMagnitude(indata);
if (outfile != null)
{
WriteData(indata_mag, outfile);
}
}
audioFile.Close();
return(indata_mag);
}
public void TestProcess()
{
Porcupine p = new Porcupine(Path.Combine(Environment.CurrentDirectory, "porcupine_params.pv"), keywordFilePath: $"{GetAbsRootPath()}resources/keyword_files/porcupine_{GetEnvironmentName()}.ppn", sensitivity: 0.5f);
Assert.AreEqual(PicoVoiceStatus.SUCCESS, p.Status, "the status of the creation of the recognition system has failed");
WAVFile file = new WAVFile();
file.Open("porcupine.wav", WAVFile.WAVFileMode.READ);
Assert.AreEqual(p.SampleRate() / 1000, file.BitsPerSample, "The samplerate is not equal!!!");
List <short> data = new List <short>();
while (file.NumSamplesRemaining > 0)
{
data.Add(BitConverter.ToInt16(file.GetNextSample_ByteArray()));
}
int framecount = (int)Math.Floor((decimal)(data.Count / p.FrameLength()));
var results = new List <bool>();
for (int i = 0; i < framecount; i++)
{
int start = i * p.FrameLength();
int count = p.FrameLength();
List <short> frame = data.GetRange(start, count);
p.Process(frame.ToArray(), out bool result);
results.Add(result);
}
var res = results.Count(x => x);
Assert.AreEqual(1, res, $"The result is not as expected, expected {1} got {res}");
p.Dispose();
}
public MemoryStream createWavMemory(Bitmap bitmap, string name, bool create_img, bool with_cue)
{
bitmap = managementGUI.resizeImage(bitmap, _scanWidth, _scanHeight, _myEyeMusic.ResizeMode);
Rectangle rect = new Rectangle(0, 0, bitmap.Width, bitmap.Height);
System.Drawing.Imaging.BitmapData bmpData = bitmap.LockBits(rect, System.Drawing.Imaging.ImageLockMode.ReadOnly, bitmap.PixelFormat);
float[,] imArr = ReconstructColor(bmpData);
bitmap.UnlockBits(bmpData);
if (create_img)
{
Bitmap clusteredImage = generatePostClassifictionBitmap(imArr);
// display image
_myEyeMusic.setScanPictureBoxes(clusteredImage);
}
MemoryStreamEM sonifiedWAV = new MemoryStreamEM();
MemoryStream toREt = sonifiedWAV.Create(_myEyeMusic.OutDirectory + "\\" + name + ".wav", false, 44100, 16);
double volume = _myEyeMusic.MyVolume;
if (_myEyeMusic.MyCueType.Equals(eyeMusic2.CueType.NoCue))
{
volume = 0.0;
}
if (with_cue)
{
short sample;
WAVFile cueWAVFile = new WAVFile(); // adding cue
cueWAVFile.Open(_myEyeMusic._mapFile + "\\Sounds\\" + _myEyeMusic.model.beep_noise, WAVFile.WAVFileMode.READ);
for (int j = 0; j < cueWAVFile.NumSamples; j++)
{
sample = (short)(volume * cueWAVFile.GetNextSample_16bit());
sample = Math.Min(short.MaxValue, sample);
sonifiedWAV.AddSample_16bit(sample);
}
cueWAVFile.Close();
}
for (int i = 0; i < _scanWidth; i++)
{
createMixer(i, sonifiedWAV, imArr);
}
sonifiedWAV.addLength();
toREt = sonifiedWAV.mFileStream;
return(toREt);
}
public void MultipleKeywords()
{
var modelFilePath = Path.GetFullPath(Path.Combine(Environment.CurrentDirectory, "porcupine_params.pv"));
Assert.IsTrue(File.Exists(modelFilePath), $"File.Exists(modelFilePath) --> {modelFilePath}");
paths.ForEach(keywordFilePath => Assert.IsTrue(File.Exists(keywordFilePath), $"File.Exists(keywordFilePath) --> {keywordFilePath}"));
Porcupine p = new Porcupine(modelFilePath, keywordFilePaths: paths, sensitivities: senses);
Assert.AreEqual(PicoVoiceStatus.SUCCESS, p.Status, "the status of the creation of the recognition system has failed");
WAVFile file = new WAVFile();
file.Open("multiple_keywords.wav", WAVFile.WAVFileMode.READ);
Assert.AreEqual(p.SampleRate(), file.AudioFormat.SampleRateHz, "The samplerate is not equal!!!");
List <short> data = new List <short>();
while (file.NumSamplesRemaining > 0)
{
data.Add(BitConverter.ToInt16(file.GetNextSample_ByteArray()));
}
int framecount = (int)Math.Floor((decimal)(data.Count / p.FrameLength()));
var results = new List <int>();
for (int i = 0; i < framecount; i++)
{
int start = i * p.FrameLength();
int count = p.FrameLength();
List <short> frame = data.GetRange(start, count);
PicoVoiceStatus status = p.ProcessMultipleKeywords(frame.ToArray(), out int result);
if (result >= 0)
{
results.Add(result);
}
Assert.AreEqual(PicoVoiceStatus.SUCCESS, status, "The status is not as expected");
}
var requiredRes = new[] { 8, 0, 1, 2, 3, 4, 5, 7, 8, 9 };
Assert.AreEqual(requiredRes.Length, results.Count, $"expected results length are different expected {requiredRes.Length} got {results.Count}");
for (var i = 0; i < results.Count; i++)
{
Assert.AreEqual(requiredRes[i], results[i], $"The result is not as expected, expected {requiredRes[i]} got {results[i]}");
}
p.Dispose();
}
public static MemoryStream encodeCompressedFromWAV(string source)
{
WAVFile wav = new WAVFile();
MemoryStream ms = new MemoryStream();
wav.Open(source, WAVFile.WAVFileMode.READ);
IMAADPCM.ADPCMState state = new IMAADPCM.ADPCMState();
byte enc1, enc2;
for (long i = 0; i < wav.NumSamples / 2; i++)
{
enc1 = IMAADPCM.encodeADPCM(wav.GetNextSampleAs16Bit(), ref state);
enc2 = IMAADPCM.encodeADPCM(wav.GetNextSampleAs16Bit(), ref state);
ms.Write(BitConverter.GetBytes(Convert.ToInt32(Utils.binaryString(enc2, 4) + Utils.binaryString(enc1, 4), 2)), 0, 1);
}
wav.Close();
return(ms);
}
public float[] GetVPFromWave(string wavefile)
{
string w = Path.GetDirectoryName(wavefile) + @"\n_" + Path.GetFileName(wavefile);
Normalize(wavefile, w);
WAVFile wave = new WAVFile();
wave.Open(w, WAVFile.WAVFileMode.READ);
float[] samples = new float[wave.NumSamples];
for (int i = 0; i < wave.NumSamples; i++)
{
samples[i] = wave.GetNextSample_16bit();
}
int cp = 0;
int t = samples.Length / 1024;
if (t > 0)
{
int r = samples.Length % 1024;
for (int x = 1; x <= t; x++)
{
Exocortex.DSP.ComplexF[] complexData = new Exocortex.DSP.ComplexF[1024];
for (int i = cp; i <= 1023; i++)
{
complexData[i].Re = samples[cp + i];
complexData[i].Im = samples[cp + i] + 5;
}
Exocortex.DSP.Fourier.FFT(complexData, complexData.Length, FourierDirection.Forward);
for (int i = 0; i <= 1023; i++)
{
samples[cp + i] = complexData[i].Re;
}
cp += 1024;
}
}
wave.Close();
return(samples);
}
byte[] GetWavData(string fileName)
{
var wav = new WAVFile();
wav.Open(fileName, WAVFile.WAVFileMode.READ);
wav.SeekToAudioDataStart();
byte[] data = new byte[wav.DataSizeBytes];
byte[] arr;
int start = 0;
do
{
arr = wav.GetNextSample_ByteArray();
arr.CopyTo(data, start);
start += arr.Length;
}while (wav.NumSamplesRemaining > 1);
wav.Close();
return(data);
}
public short[] GetSecondaryVPFromWave(string wavefile)
{
// string w = Path.GetDirectoryName(wavefile) + @"\n_" + Path.GetFileName(wavefile);
// Normalize(wavefile, w);
WAVFile wave = new WAVFile();
wave.Open(wavefile, WAVFile.WAVFileMode.READ);
short[] samples = new short[wave.NumSamples];
for (int i = 0; i < wave.NumSamples; i++)
{
samples[i] = wave.GetNextSample_16bit();
}
int cp = 0;
int t = samples.Length / 1024;
//if (t > 0)
//{
// int r = samples.Length % 1024;
// for (int x = 1; x <= t; x++)
// {
// Exocortex.DSP.ComplexF[] complexData = new Exocortex.DSP.ComplexF[1024];
// for (int i = cp; i <= 1023; i++)
// {
// complexData[i].Re = samples[cp + i];
// complexData[i].Im = samples[cp + i] + 5;
// }
// Exocortex.DSP.Fourier.FFT(complexData, complexData.Length, FourierDirection.Forward);
// for (int i = 0; i <= 1023; i++)
// samples[cp + i] = complexData[i].Re;
// cp += 1024;
// }
//}
wave.Close();
return(samples);
}
/// <summary>
/// loads the samples from WavFilePath to _samplesArray
/// </summary>
private void loadSamples()
{
//WaitForm waitForm = new WaitForm();
//ProgressBar pb = new ProgressBar();
//pb.Minimum = 0;
//WAVFileMP3 currentWAVFile;
WAVFile currentWAVFile;
string[] fileNames = Directory.GetFiles(MyFileMap + "\\" + _wavFilePath);
currentWAVFile = new WAVFile();
currentWAVFile.Open(fileNames[0], WAVFile.WAVFileMode.READ);
//pb.Maximum = fileNames.Length * currentWAVFile.NumSamples;
int seconds = (currentWAVFile.NumSamples - FirstSample);
currentWAVFile.Close();
//pb.Value = 0;
//pb.Location = new Point(40, 80);
//waitForm.Show();
//waitForm.Controls.Add(pb);
Application.DoEvents();
for (int i = 0; i < fileNames.Length; i++)
{
// Create the WAVFile object and open the current sample WAV file.
currentWAVFile = new WAVFile();
currentWAVFile.Open(fileNames[i], WAVFile.WAVFileMode.READ);
// Get the sample from the file and copy it to our array
for (int j = 0; j < currentWAVFile.NumSamples; j++)
{
_samplesArray[i, j] = currentWAVFile.GetNextSample_16bit();
}
//pb.Value += currentWAVFile.NumSamples;
currentWAVFile.Close(); // Close the WAV file
}
//waitForm.Close();
}
//methods for creating wav file
/// <summary>
/// allocates an array of according to the number of files in WavFilePath
/// </summary>
private void allocateArray()
{
int cols, rows;
string[] fileNames = Directory.GetFiles(MyFileMap + "\\" + _wavFilePath);
rows = fileNames.Length;
if (rows != _numTotalFiles)
{
throw new System.ArgumentException("total number of files must be equal to the number of files in wav folder");
}
// Set the number of cols according to the number samples in the first WAV file
//WAVFileMP3 tempWAVFile = new WAVFileMP3();
WAVFile tempWAVFile = new WAVFile();
tempWAVFile.Open(fileNames[0], WAVFile.WAVFileMode.READ);
cols = tempWAVFile.NumSamples;
tempWAVFile.Close();
// Allocate the array
_samplesArray = new short[rows, cols];
}
/// <summary>
/// Returns a WAVFormat struct containing audio format information
/// (# channels, sample rate, and bits per sample) for a WAV file.
/// </summary>
/// <param name="pFilename">The name of the file about which to retrieve format information</param>
/// <returns>A WAVFormat struct object containing the audio format information for the open file</returns>
public static WAVFormat GetAudioFormat(String pFilename)
{
WAVFormat format = new WAVFormat();
WAVFile audioFile = new WAVFile();
if (audioFile.Open(pFilename, WAVFileMode.READ).Length == 0)
{
format.BitsPerSample = audioFile.mBitsPerSample;
format.NumChannels = audioFile.mNumChannels;
format.SampleRateHz = audioFile.mSampleRateHz;
audioFile.Close();
}
return (format);
}
public static bool replaceSample(int sampleIndex, string path)
{
long offset = IVAUDSingle.WIoffset[sampleIndex] + IVAUDSingle.headerSize;
byte[] dataBefore = new byte[offset - IVAUDSingle.headerSize];
byte[] dataAfter = new byte[IVAUD.file.Length - (offset + IVAUDSingle.WInumSamplesInBytes_computed[sampleIndex])];
//Get data between header and replaced sample
IVAUD.file.Seek(IVAUDSingle.headerSize, SeekOrigin.Begin);
IVAUD.file.Read(dataBefore, 0, dataBefore.Length);
//Get data between replaced sample and eof
IVAUD.file.Seek(offset + IVAUDSingle.WInumSamplesInBytes_computed[sampleIndex], SeekOrigin.Begin);
IVAUD.file.Read(dataAfter, 0, dataAfter.Length);
//Close file
IVAUD.close();
//Open WAV file and encode it
WAVFile wav = new WAVFile();
wav.Open(path, WAVFile.WAVFileMode.READ);
MemoryStream ms = new MemoryStream();
IMAADPCM.ADPCMState state = new IMAADPCM.ADPCMState();
//byte enc1, enc2;
byte[] bytes = new byte[2];
int loopValue = ((wav.DataSizeBytes - 8) / wav.BytesPerSample);
/*Debug.WriteLine((((wav.DataSizeBytes - 8) / wav.BytesPerSample)) / 2);
* Debug.WriteLine(wav.NumSamples / 2);
* Debug.WriteLine((((wav.DataSizeBytes - 8) / wav.BytesPerSample)));
* Debug.WriteLine(wav.NumSamples);*/
//for (long i = 0; i < wav.NumSamples / 2; i++) {
for (long i = 0; i < loopValue / 2; i++)
{
bytes[0] = IMAADPCM.encodeADPCM(wav.GetNextSampleAs16Bit(), ref state);
bytes[1] = IMAADPCM.encodeADPCM(wav.GetNextSampleAs16Bit(), ref state);
ms.Write(BitConverter.GetBytes(Convert.ToInt32(Utils.binaryString(bytes[1], 4) + Utils.binaryString(bytes[0], 4), 2)), 0, 1);
}
long originalOffset = offset + IVAUDSingle.WInumSamplesInBytes_computed[sampleIndex];
//Change header values
IVAUDSingle.WInumSamplesInBytes[sampleIndex] = (int)ms.Length;
IVAUDSingle.WInumSamplesInBytes_computed[sampleIndex] = Utils.getPaddedSize(IVAUDSingle.WInumSamplesInBytes[sampleIndex]);
IVAUDSingle.WInumSamples16Bit[sampleIndex] = (int)(ms.Length * 2);
IVAUDSingle.WIsamplerate[sampleIndex] = (ushort)wav.SampleRateHz;
if (IVAUDSingle.WIHsize[sampleIndex] > 32)
{
IVAUDSingle.WInumSamples16Bit2[sampleIndex] = (uint)(ms.Length * 2);
}
//Change later offsets
long newOffset = offset + IVAUDSingle.WInumSamplesInBytes_computed[sampleIndex];
long offsetChange = newOffset - originalOffset;
for (int i = 0; i < IVAUDSingle.WIHoffset.Count; i++)
{
if ((IVAUDSingle.WIoffset[i] + IVAUDSingle.headerSize) > offset)
{
IVAUDSingle.WIoffset[i] += offsetChange;
}
}
wav.Close();
//Get WAV data
byte[] dataWAV = new byte[ms.Length];
ms.Seek(0, SeekOrigin.Begin);
ms.Read(dataWAV, 0, (int)ms.Length);
ms.Close();
//Write header
FileStream fs = new FileStream(Environment.GetEnvironmentVariable("TEMP") + "\\IVATB\\Current" + Utils.sessionID + ".tmp", FileMode.Open, FileAccess.ReadWrite);
fs.Seek(0, SeekOrigin.Begin);
if (!IVAUDSingle.write(fs))
{
return(false);
}
//Write before-data
fs.Seek(IVAUDSingle.headerSize, SeekOrigin.Begin);
fs.Write(dataBefore, 0, dataBefore.Length);
//Write sample
fs.Seek(offset, SeekOrigin.Begin);
fs.Write(dataWAV, 0, dataWAV.Length);
//Write after-data
fs.Seek(offset + IVAUDSingle.WInumSamplesInBytes_computed[sampleIndex], SeekOrigin.Begin);
fs.Write(dataAfter, 0, dataAfter.Length);
//Fix file length if needed
if (offsetChange < 0)
{
fs.SetLength(fs.Length + offsetChange);
}
fs.Close();
//Replace the file
//IVAUD.close();
//File.Copy(Environment.GetEnvironmentVariable("TEMP") + "\\IVATB\\Replace" + Utils.sessionID + ".tmp", Environment.GetEnvironmentVariable("TEMP") + "\\IVATB\\Current" + Utils.sessionID + ".tmp", true);
//Reload the file
IVAUD.load(Environment.GetEnvironmentVariable("TEMP") + "\\IVATB\\Current" + Utils.sessionID + ".tmp");
return(true);
}
/// <summary>
/// Export for use as a wavetable array in c
/// </summary>
/// <param name="filename">The completely pathed filename of the file to read</param>
public static String TableFromWav(string filename)
{
ArrayList samples = new ArrayList();
String ret = "int [] table = {";
String suff = "};";
WAVFile file = new WAVFile();
String retval = file.Open(filename, WAVFile.WAVFileMode.READ);
if (retval != "")
{
throw new WAVFileException(retval, "WAVFile.Convert_Copy()");
}
double dur = (double)file.NumSamples / file.SampleRateHz;
if (dur > 0.5)
{
MessageBox.Show("Wav File too long, please use .wavs less than 1 second long.", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
return("ERROR");
}
int lastZero = -1;
bool hasNonZero = false;
bool runOfZeros = false;
while (file.NumSamplesRemaining > 0)
{
short sample = file.GetNextSampleAs8Bit();
if (sample != 0)
{
hasNonZero = true;
runOfZeros = false;
}
else if (sample == 0 && !runOfZeros)
{
lastZero = ret.Length;
runOfZeros = true;
}
if (hasNonZero)
{
ret += sample.ToString();
ret += ",";
}
}
file.Close();
//Remove trailing zeros
ret = ret.Remove(lastZero, ret.Length - lastZero);
//Remove trailing comma
if (ret != null)
{
ret = ret.TrimEnd(',');
}
return(ret += suff);
}
/// <summary>
/// Adjusts the volume level of a WAV file, saving the adjusted file as a separate file.
/// </summary>
/// <param name="pSrcFilename">The name of the WAV file to adjust</param>
/// <param name="pDestFilename">The name to use for the volume-adjusted WAV file</param>
/// <param name="pMultiplier">The value by which to multiply the audio samples</param>
public static void AdjustVolume_Copy(String pSrcFilename, String pDestFilename, double pMultiplier)
{
// If an empty source or destination file were passed in, then throw an exception.
if (pSrcFilename.Length == 0)
throw new WAVFileReadException("Blank filename specified.", "WAVFile.AdjustVolume_Copy()");
if (pDestFilename.Length == 0)
throw new WAVFileWriteException("Blank filename specified.", "WAVFile.AdjustVolume_Copy()");
// Open the srouce file
WAVFile srcFile = new WAVFile();
String retval = srcFile.Open(pSrcFilename, WAVFileMode.READ);
if (retval.Length == 0)
{
// Check to make sure the input file has a supported number of bits/sample and sample rate. If
// not, then throw an exception.
if (!SupportedBitsPerSample(srcFile.BitsPerSample))
{
WAVFileBitsPerSampleException ex = new WAVFileBitsPerSampleException(pSrcFilename +
" has unsupported bits/sample ("
+ srcFile.BitsPerSample.ToString() + ")",
"WAVFile.AdjustVolume_Copy()", srcFile.BitsPerSample);
srcFile.Close();
throw ex;
}
// Open the destination file and start copying the adjusted audio data to it.
WAVFile destFile = new WAVFile();
destFile.Create(pDestFilename, srcFile.IsStereo, srcFile.SampleRateHz, srcFile.BitsPerSample);
if (srcFile.BitsPerSample == 8)
{
byte sample = 0;
for (int i = 0; i < srcFile.NumSamples; ++i)
{
// Note: Only multiply the sample if pMultiplier is not 1.0 (if the multiplier is
// 1.0, then it would be good to avoid any binary roundoff error).
sample = srcFile.GetNextSample_8bit();
if (pMultiplier != 1.0)
sample = (byte)((double)sample * pMultiplier);
destFile.AddSample_8bit(sample);
}
}
else if (srcFile.BitsPerSample == 16)
{
short sample = 0;
for (int i = 0; i < srcFile.NumSamples; ++i)
{
// Note: Only multiply the sample if pMultiplier is not 1.0 (if the multiplier is
// 1.0, then it would be good to avoid any binary roundoff error).
sample = srcFile.GetNextSample_16bit();
if (pMultiplier != 1.0)
sample = (short)((double)sample * pMultiplier);
destFile.AddSample_16bit(sample);
}
}
srcFile.Close();
destFile.Close();
}
else
throw new WAVFileReadException(retval, "WAVFile.AdjustVolume_Copy()");
}
/// <summary>
/// Changes the volume of a WAV file.
/// </summary>
/// <param name="pFilename">The name of the WAV file to adjust</param>
/// <param name="pMultiplier">The volume multiplier</param>
public static void AdjustVolumeInPlace(String pFilename, double pMultiplier)
{
// If pMultiplier is 1, then we don't need to do anything.
if (pMultiplier == 1.0)
return;
// Open the file
WAVFile audioFile = new WAVFile();
String retval = audioFile.Open(pFilename, WAVFileMode.READ_WRITE);
if (retval.Length == 0)
{
// Check to make sure the input file has a supported number of bits/sample and sample rate. If
// not, then throw an exception.
if (!SupportedBitsPerSample(audioFile.BitsPerSample))
{
short bitsPerSample = audioFile.BitsPerSample;
audioFile.Close();
throw new WAVFileBitsPerSampleException(pFilename + " has unsupported bits/sample ("
+ bitsPerSample.ToString() + ")",
"WAVFile.AdjustVolumeInPlace()", bitsPerSample);
}
if (!SupportedSampleRate(audioFile.SampleRateHz))
{
int sampleRate = audioFile.SampleRateHz;
audioFile.Close();
throw new WAVFileSampleRateException(pFilename + " has unsupported sample rate ("
+ sampleRate.ToString() + ")",
"WAVFile.AdjustVolumeInPlace()", sampleRate);
}
// Adjust the file volume
if (audioFile.BitsPerSample == 8)
{
byte sample = 0;
for (int sampleNum = 0; sampleNum < audioFile.NumSamples; ++sampleNum)
{
sample = (byte)((double)audioFile.GetNextSample_8bit() * pMultiplier);
audioFile.SeekToAudioSample(sampleNum);
audioFile.AddSample_8bit(sample);
}
}
else if (audioFile.BitsPerSample == 16)
{
short sample = 0;
for (int sampleNum = 0; sampleNum < audioFile.NumSamples; ++sampleNum)
{
sample = (short)((double)audioFile.GetNextSample_16bit() * pMultiplier);
audioFile.SeekToAudioSample(sampleNum);
audioFile.AddSample_16bit(sample);
}
}
audioFile.Close();
}
else
throw new WAVFileReadException(retval, "WAVFile.AdjustVolumeInPlace()");
}
/// <summary>
/// Returns the highest sample value in a WAV file, as a 16-bit value, regardless of
/// whether the file contains 8-bit or 16-bit audio. If the sample is coming from
/// an 8-bit audio file, the sample will be scaled up from 8-bit to 16-bit.
/// </summary>
/// <param name="pFilename">The audio file name</param>
/// <returns>The highest sample value from the file, as a 16-bit value</returns>
public static short HighestSampleValueAs16Bit(String pFilename)
{
short highestSample = 0;
try
{
WAVFile audioFile = new WAVFile();
if (audioFile.Open(pFilename, WAVFileMode.READ).Length == 0)
{
if (audioFile.BitsPerSample == 8)
{
short sample = 0;
for (int i = 0; i < audioFile.NumSamples; ++i)
{
sample = ScaleByteToShort(audioFile.GetNextSample_8bit());
if (sample > highestSample)
highestSample = sample;
}
}
else if (audioFile.BitsPerSample == 16)
{
short sample = 0;
for (int i = 0; i < audioFile.NumSamples; ++i)
{
sample = audioFile.GetNextSample_16bit();
if (sample > highestSample)
highestSample = sample;
}
}
audioFile.Close();
}
}
catch
{
// log exception
}
return highestSample;
}
/// <summary>
/// Returns the highest sample value in a WAV audio file.
/// The return value is a byte array and will contain one
/// byte if the file contains 8-bit audio or 2 bytes if the file
/// contains 16-bit audio. The return value will be null if
/// the file cannot be opened. If it is known that the audio
/// file contains 16-bit samples, the byte array can be converted
/// to a 16-bit integer using BitConverter.ToInt16().
/// </summary>
/// <param name="pFilename">The name of the WAV file</param>
/// <param name="pBitsPerSample">This will contain the number of bits per sample, or 0 if the file wasn't loaded.</param>
/// <returns>A byte array containing the highest audio sample, or null if the file wasn't loaded.</returns>
public static byte[] HighestSampleValue(String pFilename, out short pBitsPerSample)
{
pBitsPerSample = 0;
byte[] highestSampleValue = null;
WAVFile audioFile = new WAVFile();
try
{
if (audioFile.Open(pFilename, WAVFileMode.READ).Length == 0)
{
pBitsPerSample = audioFile.mBitsPerSample;
if (audioFile.mBitsPerSample == 8)
{
byte sample = 0;
byte highestSample = 0;
for (int i = 0; i < audioFile.NumSamples; ++i)
{
sample = audioFile.GetNextSample_8bit();
if (sample > highestSample)
highestSample = sample;
}
highestSampleValue = new byte[1];
highestSampleValue[0] = highestSample;
}
else if (audioFile.mBitsPerSample == 16)
{
short sample = 0;
short highestSample = 0;
for (int i = 0; i < audioFile.NumSamples; ++i)
{
sample = audioFile.GetNextSample_16bit();
if (sample > highestSample)
highestSample = sample;
}
highestSampleValue = BitConverter.GetBytes(highestSample);
if (!BitConverter.IsLittleEndian)
Array.Reverse(highestSampleValue);
}
audioFile.Close();
}
}
catch
{
// log exception
}
return (highestSampleValue);
}
/// <summary>
/// For 8-bit WAV files: Adjusts the volume level and converts it to a 16-bit audio file.
/// The converted data is saved to a separate file.
/// </summary>
/// <param name="pSrcFilename">The name of the WAV file to convert</param>
/// <param name="pDestFilename">The name to use for the converted WAV file</param>
/// <param name="pMultiplier">The volume multiplier</param>
public static void AdjustVolume_Copy_8BitTo16Bit(String pSrcFilename, String pDestFilename, double pMultiplier)
{
// If an empty source or destination file were passed in, then throw an exception.
if (pSrcFilename.Length == 0)
throw new WAVFileReadException("Blank filename specified.", "WAVFile.AdjustVolume_Copy_8BitTo16Bit()");
if (pDestFilename.Length == 0)
throw new WAVFileWriteException("Blank filename specified.", "WAVFile.AdjustVolume_Copy_8BitTo16Bit()");
// Open the srouce file
WAVFile srcFile = new WAVFile();
String retval = srcFile.Open(pSrcFilename, WAVFileMode.READ);
if (retval.Length == 0)
{
// Check to make sure the input file has 8 bits per sample. If not, then throw an exception.
if (srcFile.BitsPerSample != 8)
{
WAVFileBitsPerSampleException ex = new WAVFileBitsPerSampleException(pSrcFilename +
": 8 bits per sample required, and the file has " +
srcFile.BitsPerSample.ToString() + " bits per sample.",
"WAVFile.AdjustVolume_Copy_8BitTo16Bit()",
srcFile.BitsPerSample);
srcFile.Close();
throw ex;
}
// Open the destination file
WAVFile destFile = new WAVFile();
destFile.Create(pDestFilename, srcFile.IsStereo, srcFile.SampleRateHz, 16, true);
// Copy the data
short sample_16bit = 0;
while (srcFile.NumSamplesRemaining > 0)
{
// Scale the sample from 8-bit to 16 bits
sample_16bit = ScaleByteToShort(srcFile.GetNextSample_8bit());
// Now, apply pMultiplier if it is not 1.0
if (pMultiplier != 1.0)
sample_16bit = (short)((double)sample_16bit * pMultiplier);
// Save the sample to the destination file
destFile.AddSample_16bit(sample_16bit);
}
srcFile.Close();
destFile.Close();
}
else
throw new WAVFileReadException(retval, "WAVFile.AdjustVolume_Copy_8BitTo16Bit()");
}
private void frmReplace_Load(object sender, EventArgs e)
{
labelSampleSize.Text = (sampleSize / 1024).ToString() + " KB";
labelSampleDuration.Text = Utils.getDurationString(sampleSamples16Bit, sampleSampleRate);
labelSampleSampleRate.Text = sampleSampleRate.ToString() + " Hz";
labelSampleBitsPerSecond.Text = sampleBitsPerSecond.ToString();
labelSampleChannels.Text = sampleChannels.ToString();
WAVFile wav = new WAVFile();
wav.Open(WAVPath, WAVFile.WAVFileMode.READ);
labelFileSize.Text = (wav.DataSizeBytes / 1024).ToString() + " KB";
labelFileDuration.Text = Utils.getDurationString(wav.NumSamples, wav.SampleRateHz);
labelFileSampleRate.Text = wav.SampleRateHz.ToString() + " Hz";
labelFileBitsPerSecond.Text = wav.BitsPerSample.ToString();
labelFileChannels.Text = wav.NumChannels.ToString();
labelFileCodecID.Text = wav.EncodingType.ToString();
wav.Close();
if (labelFileCodecID.Text != "1")
{
labelAdvice.Text = "ERROR! The file you've chosen is not Uncompressed PCM encoded and thus cannot be used as replacement.";
labelFileCodecID.ForeColor = Color.DarkRed;
buttonReplace.Enabled = false;
return;
}
else
{
labelFileCodecID.ForeColor = Color.Green;
}
if (labelFileBitsPerSecond.Text != "16")
{
labelAdvice.Text = "ERROR! The file you've chosen does not have 16 bits per second and thus cannot be used as replacement.";
labelFileBitsPerSecond.ForeColor = Color.DarkRed;
labelSampleBitsPerSecond.ForeColor = Color.DarkRed;
buttonReplace.Enabled = false;
return;
}
else
{
labelSampleBitsPerSecond.ForeColor = Color.Green; labelFileBitsPerSecond.ForeColor = Color.Green;
}
if (labelFileChannels.Text != labelSampleChannels.Text)
{
labelAdvice.Text = "ERROR! The file you've chosen does not have the same amount of channels as the original sample and thus cannot be used as replacement.";
labelFileChannels.ForeColor = Color.DarkRed;
labelSampleChannels.ForeColor = Color.DarkRed;
buttonReplace.Enabled = false;
return;
}
else
{
labelSampleChannels.ForeColor = Color.Green; labelFileChannels.ForeColor = Color.Green;
}
if (labelFileDuration.Text != labelSampleDuration.Text)
{
labelFileDuration.ForeColor = Color.DarkGoldenrod;
labelSampleDuration.ForeColor = Color.DarkGoldenrod;
labelAdvice.ForeColor = Color.DarkGoldenrod;
labelAdvice.Text = "WARNING! The file you've chosen does not have the same duration as the original sample. It is recommended to use a file with somewhat the same duration.";
}
else
{
labelSampleDuration.ForeColor = Color.Green; labelFileDuration.ForeColor = Color.Green;
}
if (labelFileSampleRate.Text != labelSampleSampleRate.Text)
{
labelFileSampleRate.ForeColor = Color.DarkGoldenrod;
labelSampleSampleRate.ForeColor = Color.DarkGoldenrod;
labelAdvice.ForeColor = Color.DarkGoldenrod;
labelAdvice.Text = "WARNING! The file you've chosen does not have the same sample rate as the original sample. It is highly recommended to use a file with the same sample rate.";
}
else
{
labelSampleSampleRate.ForeColor = Color.Green; labelFileSampleRate.ForeColor = Color.Green;
}
labelSampleSize.ForeColor = Color.Green;
labelFileSize.ForeColor = Color.Green;
buttonReplace.Enabled = true;
if (labelAdvice.Text != "Please wait...")
{
return;
}
labelAdvice.ForeColor = Color.Green;
labelAdvice.Text = "This file looks okay as replacement. Click Replace to replace the original sample with it.";
}
/// <summary>
/// Converts a WAV file's bits/sample and number of channels to a separate WAV file.
/// </summary>
/// <param name="pSrcFilename">The name of the file to convert</param>
/// <param name="pDestFilename">The destination file name</param>
/// <param name="pBitsPerSample">The destination's number of bits/sample</param>
/// <param name="pStereo">Whether or not the destination should be stereo</param>
/// <param name="pVolumeMultiplier">A multiplier that can be used to adjust the volume of the output audio file</param>
public static void CopyAndConvert(String pSrcFilename, String pDestFilename, short pBitsPerSample, bool pStereo, double pVolumeMultiplier)
{
WAVFile srcFile = new WAVFile();
String retval = srcFile.Open(pSrcFilename, WAVFileMode.READ);
if (retval.Length > 0)
throw new WAVFileException(retval, "WAVFile.Convert_Copy()");
WAVFile destFile = new WAVFile();
destFile.Create(pDestFilename, pStereo, srcFile.SampleRateHz, pBitsPerSample);
if ((srcFile.BitsPerSample == 8) && (pBitsPerSample == 8))
{
byte sample = 0;
if (srcFile.IsStereo && !pStereo)
{
// 8-bit to 8-bit, stereo to mono: Average each 2 samples
while (srcFile.NumSamplesRemaining > 0)
{
sample = (byte)((short)((short)srcFile.GetNextSample_8bit() + (short)srcFile.GetNextSample_8bit()) / 2);
if (pVolumeMultiplier != 1.0)
sample = (byte)((double)sample * pVolumeMultiplier);
destFile.AddSample_8bit(sample);
}
}
else if ((srcFile.IsStereo && pStereo) || (!srcFile.IsStereo && !pStereo))
{
// 8-bit to 8-bit, stereo to stereo or mono to mono
while (srcFile.NumSamplesRemaining > 0)
{
sample = srcFile.GetNextSample_8bit();
if (pVolumeMultiplier != 1.0)
sample = (byte)((double)sample * pVolumeMultiplier);
destFile.AddSample_8bit(sample);
}
}
else if (!srcFile.IsStereo && pStereo)
{
// 8-bit to 8-bit, mono to stereo: Write each sample twice
while (srcFile.NumSamplesRemaining > 0)
{
sample = srcFile.GetNextSample_8bit();
if (pVolumeMultiplier != 1.0)
sample = (byte)((double)sample * pVolumeMultiplier);
destFile.AddSample_8bit(sample);
destFile.AddSample_8bit(sample);
}
}
}
else if ((srcFile.BitsPerSample == 8) && (pBitsPerSample == 16))
{
short sample = 0;
if (srcFile.IsStereo && !pStereo)
{
// 8-bit to 16 bit, stereo to mono: Average each 2 samples
while (srcFile.NumSamplesRemaining > 0)
{
sample = (short)((int)((int)srcFile.GetNextSampleAs16Bit() + (int)srcFile.GetNextSampleAs16Bit()) / 2);
if (pVolumeMultiplier != 1.0)
sample = (short)((double)sample * pVolumeMultiplier);
destFile.AddSample_16bit(sample);
}
}
else if ((srcFile.IsStereo && pStereo) || (!srcFile.IsStereo && !pStereo))
{
// 8-bit to 16 bit, stereo to stereo or mono to mono
while (srcFile.NumSamplesRemaining > 0)
{
sample = srcFile.GetNextSampleAs16Bit();
if (pVolumeMultiplier != 1.0)
sample = (short)((double)sample * pVolumeMultiplier);
destFile.AddSample_16bit(sample);
}
}
else if (!srcFile.IsStereo && pStereo)
{
// 8-bit to 16 bit, mono to stereo: Write each sample twice
while (srcFile.NumSamplesRemaining > 0)
{
sample = srcFile.GetNextSampleAs16Bit();
if (pVolumeMultiplier != 1.0)
sample = (short)((double)sample * pVolumeMultiplier);
destFile.AddSample_16bit(sample);
destFile.AddSample_16bit(sample);
}
}
}
else if ((srcFile.BitsPerSample == 16) && (pBitsPerSample == 8))
{
byte sample = 0;
if (srcFile.IsStereo && !pStereo)
{
// 16-bit to 8-bit, stereo to mono: Average each 2 samples
short sample_16bit = 0;
while (srcFile.NumSamplesRemaining > 0)
{
sample_16bit = (short)((int)srcFile.GetNextSample_16bit() + (int)srcFile.GetNextSample_16bit() / 2);
if (pVolumeMultiplier != 1.0)
sample_16bit = (short)((double)sample_16bit * pVolumeMultiplier);
sample = ScaleShortToByte(sample_16bit);
destFile.AddSample_8bit(sample);
}
}
else if ((srcFile.IsStereo && pStereo) || (!srcFile.IsStereo && !pStereo))
{
// 16-bit to 8-bit, stereo to stereo or mono to mono
while (srcFile.NumSamplesRemaining > 0)
{
sample = ScaleShortToByte(srcFile.GetNextSample_16bit());
if (pVolumeMultiplier != 1.0)
sample = (byte)((double)sample * pVolumeMultiplier);
destFile.AddSample_8bit(sample);
}
}
else if (!srcFile.IsStereo && pStereo)
{
// 16-bit to 8-bit, mono to stereo: Write each sample twice
while (srcFile.NumSamplesRemaining > 0)
{
sample = ScaleShortToByte(srcFile.GetNextSample_16bit());
if (pVolumeMultiplier != 1.0)
sample = (byte)((double)sample * pVolumeMultiplier);
destFile.AddSample_8bit(sample);
destFile.AddSample_8bit(sample);
}
}
}
else if ((srcFile.BitsPerSample == 16) && (pBitsPerSample == 16))
{
short sample = 0;
if (srcFile.IsStereo && !pStereo)
{
// 16-bit to 16-bit, stereo to mono: Average each 2 samples
while (srcFile.NumSamplesRemaining > 0)
{
sample = (short)((int)((int)srcFile.GetNextSample_16bit() + (int)srcFile.GetNextSample_16bit()) / 2);
if (pVolumeMultiplier != 1.0)
sample = (short)((double)sample * pVolumeMultiplier);
destFile.AddSample_16bit(sample);
}
}
else if ((srcFile.IsStereo && pStereo) || (!srcFile.IsStereo && !pStereo))
{
// 16-bit to 16-bit, stereo to stereo or mono to mono
while (srcFile.NumSamplesRemaining > 0)
{
sample = srcFile.GetNextSample_16bit();
if (pVolumeMultiplier != 1.0)
sample = (short)((double)sample * pVolumeMultiplier);
destFile.AddSample_16bit(sample);
}
}
else if (!srcFile.IsStereo && pStereo)
{
// 16-bit to 16-bit, mono to stereo: Write each sample twice
while (srcFile.NumSamplesRemaining > 0)
{
sample = srcFile.GetNextSample_16bit();
if (pVolumeMultiplier != 1.0)
sample = (short)((double)sample * pVolumeMultiplier);
destFile.AddSample_16bit(sample);
destFile.AddSample_16bit(sample);
}
}
}
destFile.Close();
srcFile.Close();
}
/// <summary>
/// Returns the highest number of bits per sample in a set of audio files.
/// </summary>
/// <param name="pFilenames">An array containing the audio file names</param>
/// <returns>The highest number of bits per sample in the set of audio files</returns>
public static short HighestBitsPerSample(String[] pFilenames)
{
short bitsPerSample = 0;
if (pFilenames != null)
{
WAVFile audioFile = new WAVFile();
String retval = "";
foreach (String filename in pFilenames)
{
try
{
retval = audioFile.Open(filename, WAVFileMode.READ);
if (retval.Length == 0)
{
if (audioFile.BitsPerSample > bitsPerSample)
bitsPerSample = audioFile.BitsPerSample;
audioFile.Close();
}
}
catch
{
// log exception
}
}
}
return bitsPerSample;
}
/// <summary>
/// Returns the highest number of channels in a set of audio files.
/// </summary>
/// <param name="pFilenames">An array containing the audio file names</param>
/// <returns>The highest number of channels in the set of audio files</returns>
public static byte HighestNumChannels(String[] pFilenames)
{
byte numChannels = 0;
if (pFilenames != null)
{
WAVFile audioFile = new WAVFile();
String retval = "";
foreach (String filename in pFilenames)
{
try
{
retval = audioFile.Open(filename, WAVFileMode.READ);
if (retval.Length == 0)
{
if (audioFile.NumChannels > numChannels)
numChannels = audioFile.NumChannels;
audioFile.Close();
}
}
catch
{
// log exception
}
}
}
return numChannels;
}
//Temporary function
private void barButtonItem37_ItemClick(object sender, DevExpress.XtraBars.ItemClickEventArgs e)
{
WAVFile wavFile = new WAVFile();
wavFile.Open(@"C:\Users\faris\Documents\Sigsence DeskApp V.1.0\Projects\sigsenceProject\Audio\Record_13-10-2012_18-19-46.wav", WAVFile.WAVFileMode.READ);
//wavFile.Open(@"C:\Users\faris\Documents\Sigsence DeskApp V.1.0\Projects\sigsenceProject\Audio\doh.wav", WAVFile.WAVFileMode.READ);
}
static void Main(string[] args)
{
//Debug test
//args = (@"E:\Mijn documenten\Visual Studio 2010\ADPCMEncoder\~24000HZTEST.wav|test").Split(Convert.ToChar("|"));
//args = (@"E:\Mijn documenten\Visual Studio 2010\ADPCMEncoder\TestFiles\LoadingSNOW.wav|test").Split(Convert.ToChar("|"));
//Print header
Console.WriteLine("=================");
Console.WriteLine("IMA ADPCM Encoder");
Console.WriteLine(" by Flitskikker");
Console.WriteLine("=================");
Console.WriteLine("");
//Check args
if (args.Length == 0)
{
//No args
Console.WriteLine("ERROR: No command line arguments passed. Press any key to exit...");
Console.ReadLine();
Environment.Exit(1);
}
//Check file
if (!File.Exists(args[0]))
{
//File not found
Console.WriteLine("ERROR: File \"" + args[0] + "\" not found. Press any key to exit...");
Console.ReadLine();
Environment.Exit(2);
}
//Print file
Console.WriteLine("File: " + args[0]);
Console.WriteLine("");
//Load file
WAVFile wav = new WAVFile();
wav.Open(args[0], WAVFile.WAVFileMode.READ);
//Show WAV info
Console.WriteLine("WAV Info:");
Console.WriteLine("\tBits per sample:\t" + wav.BitsPerSample.ToString() + " bits");
Console.WriteLine("\tBytes per sample:\t" + wav.BytesPerSample.ToString());
Console.WriteLine("\tBytes per second:\t" + wav.BytesPerSec.ToString());
Console.WriteLine("\tData size:\t\t" + wav.DataSizeBytes.ToString() + " bytes");
Console.WriteLine("\tDuration:\t\t" + Math.Round(Convert.ToDecimal((double)wav.NumSamples / (double)wav.SampleRateHz), 2).ToString() + " seconds (" + Utils.getDurationString(wav.NumSamples, wav.SampleRateHz) + ")");
Console.WriteLine("\tEncoding type:\t\t" + wav.EncodingType.ToString());
Console.WriteLine("\tFile size:\t\t" + wav.FileSizeBytes.ToString() + " bytes");
Console.WriteLine("\t# of channels:\t\t" + wav.NumChannels.ToString());
Console.WriteLine("\t# of samples:\t\t" + wav.NumSamples.ToString());
Console.WriteLine("\tRIFF type:\t\t" + wav.RIFFTypeString);
Console.WriteLine("\tSample Rate:\t\t" + wav.SampleRateHz.ToString() + " Hz");
Console.WriteLine("\tWAV header:\t\t" + wav.WAVHeaderString);
Console.WriteLine("");
//Check bits
if (wav.BitsPerSample != 16)
{
//Not 16 bits
Console.WriteLine("ERROR: WAV should have 16 bits per sample. Press any key to exit...");
Console.ReadLine();
Environment.Exit(1);
}
//Check bytes per sample
if (wav.BytesPerSample / wav.NumChannels != 2)
{
//Not 2 bytes
Console.WriteLine("ERROR: WAV should have (wav.NumChannels * 2) bytes per sample. Press any key to exit...");
Console.ReadLine();
Environment.Exit(1);
}
//Print message
Console.WriteLine("Ready to go! Press any key when ready...");
//Wait for input
Console.ReadLine();
if (wav.NumChannels > 1)
{
//Split channels
Console.WriteLine("");
Console.WriteLine("Saving separate channels...");
Console.WriteLine("");
List <WAVFile> wavs = new List <WAVFile>();
for (int c = 0; c < wav.NumChannels; c++)
{
wavs.Add(new WAVFile());
wavs[c].Create(Path.GetDirectoryName(args[0]) + "\\" + Path.GetFileNameWithoutExtension(args[0]) + "_" + (c + 1).ToString() + ".wav", false, wav.SampleRateHz, wav.BitsPerSample, true);
}
int numSamplesCorrected = ((wav.DataSizeBytes - 8) / wav.BytesPerSample);
//for (long i = 0; i < wav.NumSamples / wav.NumChannels; i++) {
for (long i = 0; i < numSamplesCorrected; i++)
{
for (int c = 0; c < wav.NumChannels; c++)
{
wavs[c].AddSample_16bit(wav.GetNextSampleAs16Bit());
}
}
for (int c = 0; c < wav.NumChannels; c++)
{
wavs[c].Close();
}
}
//Encode
Console.WriteLine("");
Console.WriteLine("Encoding file(s)...");
Console.WriteLine("");
IMAADPCM.ADPCMState state = new IMAADPCM.ADPCMState();
WAVFile cwav = new WAVFile();
int nc = wav.NumChannels;
for (int c = 0; c < wav.NumChannels; c++)
{
Console.WriteLine("Encoding file: " + Path.GetDirectoryName(args[0]) + "\\" + Path.GetFileNameWithoutExtension(args[0]) + "_" + (c + 1).ToString() + ".bin");
MemoryStream ms = new MemoryStream();
cwav = new WAVFile();
// Open splitted WAV
if (wav.NumChannels > 1)
{
cwav.Open(Path.GetDirectoryName(args[0]) + "\\" + Path.GetFileNameWithoutExtension(args[0]) + "_" + (c + 1).ToString() + ".wav", WAVFile.WAVFileMode.READ_WRITE);
}
else
{
cwav = wav;
//wav.Close();
//cwav.Open(args[0], WAVFile.WAVFileMode.READ_WRITE);
}
byte[] bytes = new byte[2];
int loopValue = ((cwav.DataSizeBytes - 8) / cwav.BytesPerSample);
//Actual encode
for (long i = 0; i < loopValue / 2; i++)
{
bytes[0] = IMAADPCM.encodeADPCM(cwav.GetNextSampleAs16Bit(), ref state);
bytes[1] = IMAADPCM.encodeADPCM(cwav.GetNextSampleAs16Bit(), ref state);
ms.Write(BitConverter.GetBytes(Convert.ToInt32(Utils.binaryString(bytes[1], 4) + Utils.binaryString(bytes[0], 4), 2)), 0, 1);
}
//Get WAV data
byte[] dataWAV = new byte[ms.Length];
ms.Seek(0, SeekOrigin.Begin);
ms.Read(dataWAV, 0, (int)ms.Length);
ms.Close();
//Create file
FileStream fs = new FileStream(Path.GetDirectoryName(args[0]) + "\\" + Path.GetFileNameWithoutExtension(args[0]) + "_" + (c + 1).ToString() + ".bin", FileMode.Create, FileAccess.ReadWrite);
//Write sample
fs.Seek(0, SeekOrigin.Begin);
fs.Write(dataWAV, 0, dataWAV.Length);
//Close
cwav.Close();
ms.Close();
fs.Close();
if (nc == 1)
{
break;
}
}
//Close WAV file
wav.Close();
//Print message
Console.WriteLine("");
Console.WriteLine("Done! Press any key to exit...");
//Wait for input
Console.ReadLine();
//Exit
Environment.Exit(0);
}
