static void Main(string[] args)
{
var header = new WavHeader();
var headerSize = Marshal.SizeOf(header);
Console.WriteLine("Введите путь к файлу.");
string a = Console.ReadLine();
var fileStream = new FileStream(a, FileMode.Open, FileAccess.Read);
var buffer = new byte[headerSize];
fileStream.Read(buffer, 0, headerSize);
var headerPtr = Marshal.AllocHGlobal(headerSize);
Marshal.Copy(buffer, 0, headerPtr, headerSize);
Marshal.PtrToStructure(headerPtr, header);
Console.WriteLine("Формат Кодирования: {0}", header.AudioFormat);
Console.WriteLine("Число каналов: {0}", header.NumChannels);
Console.WriteLine("Частота дискретизации: {0}", header.SampleRate);
Console.WriteLine("Битность файла: {0}", header.BitsPerSample);
var Seconds = 1.0 * header.ChunkSize / (header.BitsPerSample / 8.0) / header.NumChannels / header.SampleRate;
var Minutes = (int)Math.Floor(Seconds / 60);
Seconds = Seconds - (Minutes * 60);
Console.WriteLine("Продолжительность звучания: {0:00}:{1:00}", Minutes, Seconds);
Marshal.FreeHGlobal(headerPtr);
Console.ReadKey(true);
}
public override void ChangeStream(Stream stream)
{
if (!stream.CanRead)
{
throw new ArgumentException("WavDecoder stream can not be read");
}
var header = WavHeader.Read(stream);
if (header.AudioFormat != 1)
{
throw new ArgumentException("WavDecoder can not decode compressed wave");
}
var sampleSizeInBytes = header.BitsPerSample / 8;
this.totalSamples = header.SubChunk2Size / sampleSizeInBytes;
this.sampleRate = (int)header.SampleRate;
this.sampleSize = header.BitsPerSample;
this.channels = header.NumChannels;
if (this.sampleBuffer.Length % sampleSizeInBytes != 0)
{
var bufferSize = this.SampleBufferSize;
Array.Resize(ref this.sampleBuffer, bufferSize + (bufferSize % sampleSizeInBytes));
}
this.stream?.Dispose();
this.stream = stream;
}
public WFOTransporter(WaveFileObject obj)
{
this.header = obj.header;
switch (obj.header.bit)
{
case 16:
arrShort = new short[obj.soundData.Count];
for (int i = 0; i < obj.soundData.Count; i++)
{
arrShort[i] = (short)obj.soundData[i];
}
break;
case 32:
arrInt = new uint[obj.soundData.Count];
for (int i = 0; i < obj.soundData.Count; i++)
{
arrInt[i] = (uint)obj.soundData[i];
}
break;
case 64:
arrDouble = new double[obj.soundData.Count];
for (int i = 0; i < obj.soundData.Count; i++)
{
arrDouble[i] = (double)obj.soundData[i];
}
break;
default:
break;
}
}
private async void Button1_ClickAsync(object sender, EventArgs e)
{
using (OpenFileDialog openFileDialog = new OpenFileDialog())
{
openFileDialog.InitialDirectory = "c:\\";
openFileDialog.Filter = "wav files (*.wav)|*.wav";
openFileDialog.FilterIndex = 2;
openFileDialog.RestoreDirectory = true;
if (openFileDialog.ShowDialog() == DialogResult.OK)
{
filePath = openFileDialog.FileName;
var header = new WavHeader();
// Размер заголовка
var headerSize = Marshal.SizeOf(header);
var fileStream = new FileStream(filePath, FileMode.Open, FileAccess.Read);
var buffer = new byte[headerSize];
fileStream.Read(buffer, 0, headerSize);
// Чтобы не считывать каждое значение заголовка по отдельности,
// воспользуемся выделением unmanaged блока памяти
var headerPtr = Marshal.AllocHGlobal(headerSize);
// Копируем считанные байты из файла в выделенный блок памяти
Marshal.Copy(buffer, 0, headerPtr, headerSize);
// Преобразовываем указатель на блок памяти к нашей структуре
Marshal.PtrToStructure(headerPtr, header);
Console.WriteLine("Sample rate: {0}", header.SampleRate);
Console.WriteLine("Channels: {0}", header.NumChannels);
Console.WriteLine("Bits per sample: {0}", header.BitsPerSample);
int sizeOfLayer = header.BitsPerSample * 1024;
var array = File.ReadAllBytes(filePath);
if (checkBox1.Checked == false)
{
int counter = 44;
byte[] sounds;
do
{
sounds = new byte[sizeOfLayer];
sounds = array.Skip(counter).Take(sizeOfLayer).ToArray();
SendWebReqestAsync(sounds);
counter += sizeOfLayer;
}while (counter < array.Length);
}
//var result = await GetAnswer(pathToServer);
// Освобождаем выделенный блок памяти
Marshal.FreeHGlobal(headerPtr);
}
}
}
/// <summary>
/// Создает экземпляр WavData с указанным заголовком и массивом данных
/// </summary>
public WavData(WavHeader hdr, byte[] d)
{
Header = hdr;
Data = d;
MemoryStream ms = new MemoryStream(Data);
_read = new BinaryReader(ms);
_write = new BinaryWriter(ms);
}
/// <summary>
/// Создает экземпляр WavData с указанным заголовком и пустым массивом данных указанного размера
/// </summary>
public WavData(WavHeader hdr, int size)
{
Header = hdr;
Data = new byte[size];
MemoryStream ms = new MemoryStream(Data);
_read = new BinaryReader(ms);
_write = new BinaryWriter(ms);
}
/// <summary>
/// ストリームをオープンしてwavファイルのヘッダ部を読み出します。
/// それにより総再生時間を割り出します。
/// 読み込みが終了したらCloseReader()を必ず実行してください。
/// </summary>
public int ReadHeader()
{
this.Header = new WavHeader();
this.fs = new FileStream(this.FilePath, FileMode.Open);
this.br = new BinaryReader(fs);
this.Header.riffID = br.ReadBytes(4);
this.Header.size = br.ReadUInt32();
this.Header.wavID = br.ReadBytes(4);
//byte(1byte)からchar(2byte),charからstringへ型変換
char[] charstr = new char[4] {
(char)this.Header.wavID[0], (char)this.Header.wavID[1], (char)this.Header.wavID[2], (char)this.Header.wavID[3]
};
string str = new String(charstr);
//wavファイルでなければ弾く
if (str != "WAVE")
{
throw new ArgumentException(this.FilePath + "には対応していません:wavID");
}
this.Header.fmtID = br.ReadBytes(4);
this.Header.fmtSize = br.ReadUInt32();
this.Header.format = br.ReadUInt16();
this.Header.channels = br.ReadUInt16();
//モノラルじゃなければ弾く
if (this.Header.channels != CHANNELS)
{
throw new ArgumentException(this.FilePath + "には対応していません:channnels");
}
this.Header.sampleRate = br.ReadUInt32();
//サンプリングレートが違うと弾く
if (this.Header.sampleRate != SRATE)
{
throw new ArgumentException(this.FilePath + "には対応していません:SRATE");
}
this.Header.bytePerSec = br.ReadUInt32();
this.Header.blockSize = br.ReadUInt16();
this.Header.bit = br.ReadUInt16();
//量子化ビット数が違うと弾く
if (this.Header.bit != QUANTUMBIT)
{
throw new ArgumentException(this.FilePath + "には対応していません:QBIT");
}
this.Header.dataID = br.ReadBytes(4);
this.Header.dataSize = br.ReadUInt32();
//44バイト読み込み
//ファイルサイズから再生時間を逆算
this.PlayBackTime = (int)(Header.dataSize / (Header.sampleRate * (Header.bit / BYTE) * Header.channels));
return(this.PlayBackTime);
}
public WaveFileObject[] ToWaveChunksWithOverlaps(int ms, WaveFileObject obj)
{
double secs = ms / 1000d;
long chunkSamples = (long)(obj.header.sampleRate * secs);
long chunkCount = (((obj.header.dataSize / obj.header.blockSize) / chunkSamples) * 2) - 2;
WaveFileObject[] waves = new WaveFileObject[chunkCount];
int osIndex = 0;
for (int i = 0; i < chunkCount; i++)
{
waves[i] = new WaveFileObject();
WavHeader tempHeader = header;
if (header.bit == 16)
{
tempHeader.dataSize = (uint)chunkSamples * 2;
tempHeader.blockSize = 2;
waves[i].soundData = new List <ushort>();
}
if (header.bit == 32)
{
tempHeader.dataSize = (uint)chunkSamples * 4;
tempHeader.blockSize = 4;
waves[i].soundData = new List <uint>();
}
if (header.bit == 64)
{
tempHeader.dataSize = (uint)chunkSamples * 8;
tempHeader.blockSize = 8;
waves[i].soundData = new List <double>();
}
waves[i].header = tempHeader;
}
for (int i = 0; i < chunkCount; i++)
{
for (int j = 0; j < chunkSamples; j++)
{
if (!IsOdd(i))
{
waves[i].soundData.Add(obj.soundData[osIndex]);
osIndex++;
}
else
{
waves[i].soundData.Add(obj.soundData[osIndex + j - (int)(chunkSamples * .5)]);
}
}
}
return(waves);
}
public void Header()
{
WavHeader header = GetHeader();
using (var memory = new MemoryStream())
{
var writer = new WavWriter(memory, header);
writer.ToString(); // we just need it to process header
Assert.AreEqual(WavHeader.Size + WavChunkHeader.Size, memory.Position);
}
}
public void GetAll()
{
var graphics = new List <double[]>();
var neededDir = $"{AssemblyDirectory}Resources";
foreach (var file in Directory.GetFiles(neededDir))
{
var panorama = WavHeader.GetSpectrumFromFile(file);
graphics.Add(panorama.CenterData.ToArray());
}
Graphics = graphics;
}
public static IList <short> Read(string filename)
{
WavHeader Header = new WavHeader();
List <short> lDataList = new List <short>();
List <short> rDataList = new List <short>();
using (FileStream fs = new FileStream(filename, FileMode.Open, FileAccess.Read))
using (BinaryReader br = new BinaryReader(fs))
{
try
{
Header.riffID = br.ReadBytes(4);
Header.size = br.ReadUInt32();
Header.wavID = br.ReadBytes(4);
Header.fmtID = br.ReadBytes(4);
Header.fmtSize = br.ReadUInt32();
Header.format = br.ReadUInt16();
Header.channels = br.ReadUInt16();
Header.sampleRate = br.ReadUInt32();
Header.bytePerSec = br.ReadUInt32();
Header.blockSize = br.ReadUInt16();
Header.bit = br.ReadUInt16();
Header.dataID = br.ReadBytes(4);
Header.dataSize = br.ReadUInt32();
// for (int i = 0; i < Header.dataSize / Header.blockSize; i++)
while (fs.Position < fs.Length)
{
lDataList.Add((short)(((short)br.ReadUInt16())));
if (Header.channels == 2 && fs.Position < fs.Length)
{
rDataList.Add((short)br.ReadUInt16());
}
}
}
finally
{
if (br != null)
{
br.Close();
}
if (fs != null)
{
fs.Close();
}
}
}
return(lDataList);
}
/// <summary>
/// ファイルストリームを開きヘッダ情報のみのwavファイルを作成します。
/// 同名のファイルがある場合上書きされます。
/// ファイルストリームを開くので書き込みが終了したらCloseWriter()を実行してください。
/// </summary>
/// <returns>作成したファイルのパス</returns>
public string HeaderWrite()
{
WavHeader Header = new WavHeader();
//riffID
Header.riffID = new byte[] { (byte)'R', (byte)'I', (byte)'F', (byte)'F' };
//データサイズ
Header.size = (SRATE * (QUANTUMBIT / BYTE) * CHANNELS * this.RecTime) + (uint)Marshal.SizeOf(typeof(WavHeader));
//waveID
Header.wavID = new byte[] { (byte)'W', (byte)'A', (byte)'V', (byte)'E' };
//fmtID
Header.fmtID = new byte[] { (byte)'f', (byte)'m', (byte)'t', (byte)' ' };
//fmtチャンクのバイト数
Header.fmtSize = 16;
//WAVE_FORMAT_PCMであることを示す＝１
Header.format = 1;
//チャンネル数
Header.channels = CHANNELS;
//サンプリングレート
Header.sampleRate = SRATE;
//samplerate/byte/channels
Header.bytePerSec = SRATE * (QUANTUMBIT / BYTE) * CHANNELS;
//byte/sample*channels 16bit/stereoなら2*2=4 blockAlignと同等？
Header.blockSize = (ushort)((QUANTUMBIT / BYTE) * CHANNELS);
//ビットレート
Header.bit = (ushort)QUANTUMBIT;
//dataチャンクを示す
Header.dataID = new byte[] { (byte)'d', (byte)'a', (byte)'t', (byte)'a' };
//データ長
Header.dataSize = SRATE * (QUANTUMBIT / BYTE) * this.RecTime;
//ヘッダ情報を書き込みます。
this.fs = new FileStream(this.FilePath, FileMode.Create);
this.bw = new BinaryWriter(this.fs);
bw.Write(Header.riffID);
bw.Write(Header.size);
bw.Write(Header.wavID);
bw.Write(Header.fmtID);
bw.Write(Header.fmtSize);
bw.Write(Header.format);
bw.Write(Header.channels);
bw.Write(Header.sampleRate);
bw.Write(Header.bytePerSec);
bw.Write(Header.blockSize);
bw.Write(Header.bit);
bw.Write(Header.dataID);
bw.Write(Header.dataSize);
return(this.FilePath);
}
public WavData ReadData()
{
var header = new WavHeader();
byte[] data;
using (var fs = new FileStream(FilePath, FileMode.Open, FileAccess.Read))
{
using (var reader = new BinaryReader(fs))
{
//считываем заголовок
header.ChunkId = reader.ReadInt32();
header.ChunkSize = reader.ReadInt32();
header.Format = reader.ReadInt32();
header.Subchunk1Id = reader.ReadInt32();
header.Subchunk1Size = reader.ReadInt32();
header.AudioFormat = reader.ReadInt16();
header.NumChannels = reader.ReadInt16();
header.SampleRate = reader.ReadInt32();
header.ByteRate = reader.ReadInt32();
header.BlockAlign = reader.ReadInt16();
header.BitsPerSample = reader.ReadInt16();
if (header.Subchunk1Size == 18)
{
header.FmtExtraSize = reader.ReadInt16();
reader.ReadBytes(header.FmtExtraSize);
}
//пытаемся считать данные
header.Subchunk2Id = reader.ReadInt32();
header.Subchunk2Size = reader.ReadInt32();
while (true)
{
data = reader.ReadBytes(header.Subchunk2Size);
if (header.Subchunk2Id == 0x61746164)
{
break;
} //данные найдены
//если Subchunk2Id нет тот, что ожидался, пропускаем и пробуем снова
header.Subchunk2Id = reader.ReadInt32();
header.Subchunk2Size = reader.ReadInt32();
}
}
}
var result = new WavData(header, data);
return(result);
}
private void wavHeaderButton_Click(object sender, EventArgs e)
{
if (fileName != null && fileName.EndsWith(".wav"))
{
WavHeader Header = new WavHeader();
FileStream fs = new FileStream(fileName, FileMode.Open, FileAccess.Read);
BinaryReader br = new BinaryReader(fs);
Header.riffID = br.ReadBytes(4);
Header.size = br.ReadUInt32();
Header.wavID = br.ReadBytes(4);
Header.fmtID = br.ReadBytes(4);
Header.fmtSize = br.ReadUInt32();
Header.format = br.ReadUInt16();
Header.channels = br.ReadUInt16();
Header.sampleRate = br.ReadUInt32();
Header.bytePerSec = br.ReadUInt32();
Header.blockSize = br.ReadUInt16();
Header.bit = br.ReadUInt16();
Header.dataID = br.ReadBytes(4);
Header.dataSize = br.ReadUInt32();
messageBox.Text = " ";
string text;
int index = fileName.LastIndexOf("\\");
messageBox.Text += "_____" + fileName.Substring(index + 1) + "_____ \n";
text = System.Text.Encoding.UTF8.GetString(Header.riffID);
messageBox.Text += "RiffID: " + text + "\n";
messageBox.Text += "Size: " + Header.size + "\n";
text = System.Text.Encoding.UTF8.GetString(Header.wavID);
messageBox.Text += "WavID: " + text + "\n";
text = System.Text.Encoding.UTF8.GetString(Header.fmtID);
messageBox.Text += "FtmID: " + text + "\n";
messageBox.Text += "FtmSize: " + Header.fmtSize + "\n";
messageBox.Text += "Format: " + Header.format + "\n";
messageBox.Text += "Channels: " + Header.channels + "\n";
messageBox.Text += "SampleRate: " + Header.sampleRate + "\n";
messageBox.Text += "BytePerSec: " + Header.bytePerSec + "\n";
messageBox.Text += "BlockSize: " + Header.blockSize + "\n";
messageBox.Text += "Bit: " + Header.bit + "\n";
text = System.Text.Encoding.UTF8.GetString(Header.dataID);
messageBox.Text += "DataID: " + text + "\n";
messageBox.Text += "DataSize: " + Header.dataSize + "\n";
}
else
{
MessageBox.Show("Nie wybrano pliku lub wybrany plik jest nieprawidłowy");
}
}
private unsafe List <byte> decompressDPCM(ushort *delta, byte *buffer, uint bufferLen)
{
int position = 0;
List <byte> decompressed = new List <byte>();
if (!wavHeaderRead)
{
position += sizeof(WavHeader);
var newHeader = new WavHeader();
byte *wavHeaderBytes = (byte *)&newHeader;
Decrypt(buffer, wavHeaderBytes, sizeof(WavHeader));
for (var i = 0; i < sizeof(WavHeader); i++)
{
decompressed.Add(wavHeaderBytes[i]);
}
wavHeader = newHeader;
wavHeaderRead = true;
}
if (wavHeader.channels == 1)
{
decompressed.Add(buffer[position]);
decompressed.Add(buffer[position + 1]);
ushort value = *((ushort *)&(buffer[position]));
position += 2;
while (position < bufferLen)
{
int sign = (buffer[position] & 0x80) == 0 ? 1 : -1;
value += (ushort)(sign * delta[buffer[position] & 0x7f]);
decompressed.Add((byte)(value & 0xff));
decompressed.Add((byte)(value >> 8));
position += 1;
}
}
else
{
// TODO: find a stereo WAV and implement this or prove there are no stereo WAVs
}
return(decompressed);
}
public WaveFileObject(string path)
{
header = new WavHeader();
using (FileStream fs = new FileStream(path, FileMode.Open))
using (BinaryReader br = new BinaryReader(fs))
{
try
{
header.riff = br.ReadBytes(4);
header.size = br.ReadUInt32();
header.wavID = br.ReadBytes(4);
header.fmtID = br.ReadBytes(4);
header.fmtSize = br.ReadUInt32();
header.format = br.ReadUInt16();
header.channels = br.ReadUInt16();
header.sampleRate = br.ReadUInt32();
header.bytePerSec = br.ReadUInt32();
header.blockSize = br.ReadUInt16();
header.bit = br.ReadUInt16();
header.dataID = br.ReadBytes(4);
header.dataSize = br.ReadUInt32();
for (int i = 0; i < header.dataSize / header.blockSize; i++)
{
soundData.Add((short)br.ReadUInt16());
}
}
catch (Exception e)
{
Console.WriteLine(e.Message);
throw;
}
finally
{
if (br != null)
{
br.Close();
}
if (fs != null)
{
fs.Close();
}
}
}
}
public static WavHeader GetWavInfo(string file)
{
WavHeader header = new WavHeader();
using (FileStream fileStream = new FileStream(file, FileMode.Open, FileAccess.Read))
using (BinaryReader reader = new BinaryReader(fileStream))
{
byte[] wave = reader.ReadBytes(24);
fileStream.Position = 0;
header.ChunkID = reader.ReadInt32();
header.FileSize = reader.ReadInt32();
string formats = Encoding.Default.GetString(wave);
header.ChunkFormat = formats.Substring(0, 6);
header.FileFormat = formats.Substring(8, 4);
header.Subchunk1ID = formats.Substring(12, 4);
header.Subchunk1Size = reader.ReadInt32();
}
return(header);
}
private void waveIn_DataAvailable(object sender, WaveInEventArgs e)
{
if (!m_is_line_snd)
{
m_is_line_snd = true;
WavHeader wh = new WavHeader();
byte[] temp1 = wh.GetWavHeader();
byte[] temp = new byte[44];
Array.Copy(temp1, 0, temp, 0, temp1.Length);
m_queue_rec.Enqueue(temp, temp.Length);
m_thread_rec = new Thread(ThreadDoRec);
m_thread_rec.IsBackground = false;
m_thread_rec.Start();
}
m_queue_rec.Enqueue(e.Buffer, 800);
m_queue_rec.Enqueue(e.Buffer.Skip(800).Take(800).ToArray(), 800);
}
public WaveFileObject(WFOTransporter transporter)
{
this.header = transporter.header;
switch (transporter.header.bit)
{
case 16:
this.soundData = transporter.arrShort.ToList();
break;
case 32:
this.soundData = transporter.arrInt.ToList();
break;
case 64:
this.soundData = transporter.arrDouble.ToList();
break;
default:
break;
}
}
public async Task FlushUpdatesSizes()
{
WavHeader header = GetHeader();
using (var memory = new MemoryStream())
{
var writer = new WavWriter(memory, header);
var data = new byte[12];
await writer.Write(data, 0, data.Length);
writer.Flush();
// read data, that has been written above
memory.Position = 0;
var reader = new WavReader(memory);
var h = reader.ReadChunkHeader();
Assert.AreEqual(WavHeader.Size + WavChunkHeader.Size - 8 + data.Length, reader.Header.FileSize);
Assert.AreEqual(data.Length, h.ChunkLength);
}
}
static WavHeader wavHeader(string file)
{
var header = new WavHeader();
// Размер заголовка
var headerSize = Marshal.SizeOf(header);
var fileStream = new FileStream(file, FileMode.Open, FileAccess.Read);
var buffer = new byte[headerSize];
fileStream.Read(buffer, 0, headerSize);
// Чтобы не считывать каждое значение заголовка по отдельности,
// воспользуемся выделением unmanaged блока памяти
var headerPtr = Marshal.AllocHGlobal(headerSize);
// Копируем считанные байты из файла в выделенный блок памяти
Marshal.Copy(buffer, 0, headerPtr, headerSize);
// Преобразовываем указатель на блок памяти к нашей структуре
Marshal.PtrToStructure(headerPtr, header);
// Выводим полученные данные
Console.WriteLine("Sample rate: {0}", header.SampleRate);
Console.WriteLine("Channels: {0}", header.NumChannels);
Console.WriteLine("Bits per sample: {0}", header.BitsPerSample);
// Посчитаем длительность воспроизведения в секундах
var durationSeconds = 1.0 * header.Subchunk2Size / (header.BitsPerSample / 8.0) / header.NumChannels / header.SampleRate;
var durationMinutes = (int)Math.Floor(durationSeconds / 60);
durationSeconds = durationSeconds - (durationMinutes * 60);
Console.WriteLine("Duration: {0:00}:{1:00}", durationMinutes, durationSeconds);
//Console.ReadKey();
// Освобождаем выделенный блок памяти
Marshal.FreeHGlobal(headerPtr);
return(header);
}
public static void Save(SoundData soundData, Stream stream)
{
if (soundData == null)
{
throw new ArgumentNullException("soundData");
}
if (stream == null)
{
throw new ArgumentNullException("stream");
}
EngineBinaryWriter engineBinaryWriter = new EngineBinaryWriter(stream);
WavHeader structure = default(WavHeader);
structure.Riff = MakeFourCC("RIFF");
structure.FileSize = Utilities.SizeOf <WavHeader>() + Utilities.SizeOf <FmtHeader>() + Utilities.SizeOf <DataHeader>() + soundData.Data.Length;
structure.Wave = MakeFourCC("WAVE");
engineBinaryWriter.WriteStruct(structure);
FmtHeader structure2 = default(FmtHeader);
structure2.Fmt = MakeFourCC("fmt ");
structure2.FormatSize = 16;
structure2.Type = 1;
structure2.ChannelsCount = (short)soundData.ChannelsCount;
structure2.SamplingFrequency = soundData.SamplingFrequency;
structure2.BytesPerSecond = soundData.ChannelsCount * 2 * soundData.SamplingFrequency;
structure2.BytesPerSample = (short)(soundData.ChannelsCount * 2);
structure2.BitsPerChannel = 16;
engineBinaryWriter.WriteStruct(structure2);
DataHeader structure3 = default(DataHeader);
structure3.Data = MakeFourCC("data");
structure3.DataSize = soundData.Data.Length * 2;
engineBinaryWriter.WriteStruct(structure3);
byte[] array = new byte[soundData.Data.Length * 2];
Buffer.BlockCopy(soundData.Data, 0, array, 0, array.Length);
stream.Write(array, 0, array.Length);
}
private void CodeDpcm_Click(object sender, RoutedEventArgs e)
{
lock (this)
{
CodDpcm.Label = "Codificando...";
var task = Task.Run(async() =>
{
string folder = (await StorageLibrary.GetLibraryAsync(KnownLibraryId.Music)).SaveFolder.Path;
header = WavController.OpenWavFile(Path.Combine(folder, "PCM_original.wav"), out left, out right);
dpcmLib.PreQuantizar(-1, 1, sizeQuantizer, out particao, out codebook);
double MsqLeft = dpcmLib.meansqr(left);
//double MsqRight = dpcmLib.meansqr(right);
PreditorLeft = dpcmLib.GerarPreditor(PreditorCorrelacoes.VozHumana, MsqLeft); // Coeficientes do preditor esquerdo
//PreditorRight = dpcmLib.GerarPreditor(PreditorCorrelacoes.VozHumana, MsqRight); // Coeficientes do preditor esquerdo
dpcmLeft = dpcmLib.DPCMEncoding(left, particao, codebook, PreditorLeft);
//dpcmRight = dpcmLib.DPCMEncoding(right, particao, codebook, PreditorRight);
WavController.SaveWavFile(Path.Combine(folder, "DPCM.wav"), dpcmLeft, dpcmLeft, 8, header);
await Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () => CodDpcm.Label = "Codificar");
});
}
}
private void SaveToWav()
{
FileStream fs = null;
int channels = 0, bits = 0;
float rate = 0;
IntPtr ptr1 = new IntPtr(), ptr2 = new IntPtr();
uint lenbytes = 0, len1 = 0, len2 = 0;
FMOD.SOUND_TYPE type = FMOD.SOUND_TYPE.WAV;
FMOD.SOUND_FORMAT format = FMOD.SOUND_FORMAT.NONE;
int temp1 = 0;
float temp3 = 0;
if (sound == null)
{
return;
}
sound.getFormat (ref type, ref format, ref channels, ref bits);
sound.getDefaults(ref rate, ref temp3, ref temp3, ref temp1);
sound.getLength (ref lenbytes, FMOD.TIMEUNIT.PCMBYTES);
FmtChunk fmtChunk = new FmtChunk();
DataChunk dataChunk = new DataChunk();
WavHeader wavHeader = new WavHeader();
RiffChunk riffChunk = new RiffChunk();
fmtChunk.chunk = new RiffChunk();
fmtChunk.chunk.id = new char[4];
fmtChunk.chunk.id[0] = 'f';
fmtChunk.chunk.id[1] = 'm';
fmtChunk.chunk.id[2] = 't';
fmtChunk.chunk.id[3] = ' ';
fmtChunk.chunk.size = Marshal.SizeOf(fmtChunk) - Marshal.SizeOf(riffChunk);
fmtChunk.wFormatTag = 1;
fmtChunk.nChannels = (ushort)channels;
fmtChunk.nSamplesPerSec = (uint)rate;
fmtChunk.nAvgBytesPerSec = (uint)(rate * channels * bits / 8);
fmtChunk.nBlockAlign = (ushort)(1 * channels * bits / 8);
fmtChunk.wBitsPerSample = (ushort)bits;
dataChunk.chunk = new RiffChunk();
dataChunk.chunk.id = new char[4];
dataChunk.chunk.id[0] = 'd';
dataChunk.chunk.id[1] = 'a';
dataChunk.chunk.id[2] = 't';
dataChunk.chunk.id[3] = 'a';
dataChunk.chunk.size = (int)lenbytes;
wavHeader.chunk = new RiffChunk();
wavHeader.chunk.id = new char[4];
wavHeader.chunk.id[0] = 'R';
wavHeader.chunk.id[1] = 'I';
wavHeader.chunk.id[2] = 'F';
wavHeader.chunk.id[3] = 'F';
wavHeader.chunk.size = (int)(Marshal.SizeOf(fmtChunk) + Marshal.SizeOf(riffChunk) + lenbytes);
wavHeader.rifftype = new char[4];
wavHeader.rifftype[0] = 'W';
wavHeader.rifftype[1] = 'A';
wavHeader.rifftype[2] = 'V';
wavHeader.rifftype[3] = 'E';
fs = new FileStream("record.wav", FileMode.Create, FileAccess.Write);
/*
Write out the WAV header.
*/
IntPtr wavHeaderPtr = Marshal.AllocHGlobal(Marshal.SizeOf(wavHeader));
IntPtr fmtChunkPtr = Marshal.AllocHGlobal(Marshal.SizeOf(fmtChunk));
IntPtr dataChunkPtr = Marshal.AllocHGlobal(Marshal.SizeOf(dataChunk));
byte []wavHeaderBytes = new byte[Marshal.SizeOf(wavHeader)];
byte []fmtChunkBytes = new byte[Marshal.SizeOf(fmtChunk)];
byte []dataChunkBytes = new byte[Marshal.SizeOf(dataChunk)];
Marshal.StructureToPtr(wavHeader, wavHeaderPtr, false);
Marshal.Copy(wavHeaderPtr, wavHeaderBytes, 0, Marshal.SizeOf(wavHeader));
Marshal.StructureToPtr(fmtChunk, fmtChunkPtr, false);
Marshal.Copy(fmtChunkPtr, fmtChunkBytes, 0, Marshal.SizeOf(fmtChunk));
Marshal.StructureToPtr(dataChunk, dataChunkPtr, false);
Marshal.Copy(dataChunkPtr, dataChunkBytes, 0, Marshal.SizeOf(dataChunk));
fs.Write(wavHeaderBytes, 0, Marshal.SizeOf(wavHeader));
fs.Write(fmtChunkBytes, 0, Marshal.SizeOf(fmtChunk));
fs.Write(dataChunkBytes, 0, Marshal.SizeOf(dataChunk));
/*
Lock the sound to get access to the raw data.
*/
sound.@lock(0, lenbytes, ref ptr1, ref ptr2, ref len1, ref len2);
/*
Write it to disk.
*/
byte []rawdata = new byte[len1];
Marshal.Copy(ptr1, rawdata, 0, (int)len1);
fs.Write(rawdata, 0, (int)len1);
/*
Unlock the sound to allow FMOD to use it again.
*/
sound.unlock(ptr1, ptr2, len1, len2);
fs.Close();
MessageBox.Show("Written to record.wav");
}
public static void WriteWavHeader(FileStream stream, FMOD.Sound sound, int length, Object usingFmod)
{
FMOD.SOUND_TYPE type = FMOD.SOUND_TYPE.UNKNOWN;
FMOD.SOUND_FORMAT format = FMOD.SOUND_FORMAT.NONE;
int channels = 0, bits = 0, temp1 = 0;
float rate = 0.0f;
float temp = 0.0f;
if (sound == null)
{
return;
}
lock (usingFmod) {
sound.getFormat(ref type, ref format, ref channels, ref bits);
sound.getDefaults(ref rate, ref temp, ref temp, ref temp1);
}
log.Info("WaveWriter.WriteWavHeader: sound format: dataLength " + length + ", type " + type + ", format " + format +
", channels " + channels + ", bits " + bits + ", rate " + rate);
stream.Seek(0, SeekOrigin.Begin);
FmtChunk fmtChunk = new FmtChunk();
DataChunk dataChunk = new DataChunk();
WavHeader wavHeader = new WavHeader();
RiffChunk riffChunk = new RiffChunk();
fmtChunk.chunk = new RiffChunk();
fmtChunk.chunk.id = new char[4];
fmtChunk.chunk.id[0] = 'f';
fmtChunk.chunk.id[1] = 'm';
fmtChunk.chunk.id[2] = 't';
fmtChunk.chunk.id[3] = ' ';
fmtChunk.chunk.size = Marshal.SizeOf(fmtChunk) - Marshal.SizeOf(riffChunk);
fmtChunk.wFormatTag = 1;
fmtChunk.nChannels = (ushort)channels;
fmtChunk.nSamplesPerSec = (uint)rate;
fmtChunk.nAvgBytesPerSec = (uint)(rate * channels * bits / 8);
fmtChunk.nBlockAlign = (ushort)(1 * channels * bits / 8);
fmtChunk.wBitsPerSample = (ushort)bits;
dataChunk.chunk = new RiffChunk();
dataChunk.chunk.id = new char[4];
dataChunk.chunk.id[0] = 'd';
dataChunk.chunk.id[1] = 'a';
dataChunk.chunk.id[2] = 't';
dataChunk.chunk.id[3] = 'a';
dataChunk.chunk.size = (int)length;
wavHeader.chunk = new RiffChunk();
wavHeader.chunk.id = new char[4];
wavHeader.chunk.id[0] = 'R';
wavHeader.chunk.id[1] = 'I';
wavHeader.chunk.id[2] = 'F';
wavHeader.chunk.id[3] = 'F';
wavHeader.chunk.size = (int)(Marshal.SizeOf(fmtChunk) + Marshal.SizeOf(riffChunk) + length);
wavHeader.rifftype = new char[4];
wavHeader.rifftype[0] = 'W';
wavHeader.rifftype[1] = 'A';
wavHeader.rifftype[2] = 'V';
wavHeader.rifftype[3] = 'E';
/*
* Write out the WAV header.
*/
IntPtr wavHeaderPtr = Marshal.AllocHGlobal(Marshal.SizeOf(wavHeader));
IntPtr fmtChunkPtr = Marshal.AllocHGlobal(Marshal.SizeOf(fmtChunk));
IntPtr dataChunkPtr = Marshal.AllocHGlobal(Marshal.SizeOf(dataChunk));
byte [] wavHeaderBytes = new byte[Marshal.SizeOf(wavHeader)];
byte [] fmtChunkBytes = new byte[Marshal.SizeOf(fmtChunk)];
byte [] dataChunkBytes = new byte[Marshal.SizeOf(dataChunk)];
Marshal.StructureToPtr(wavHeader, wavHeaderPtr, false);
Marshal.Copy(wavHeaderPtr, wavHeaderBytes, 0, Marshal.SizeOf(wavHeader));
Marshal.StructureToPtr(fmtChunk, fmtChunkPtr, false);
Marshal.Copy(fmtChunkPtr, fmtChunkBytes, 0, Marshal.SizeOf(fmtChunk));
Marshal.StructureToPtr(dataChunk, dataChunkPtr, false);
Marshal.Copy(dataChunkPtr, dataChunkBytes, 0, Marshal.SizeOf(dataChunk));
stream.Write(wavHeaderBytes, 0, Marshal.SizeOf(wavHeader));
stream.Write(fmtChunkBytes, 0, Marshal.SizeOf(fmtChunk));
stream.Write(dataChunkBytes, 0, Marshal.SizeOf(dataChunk));
}
public WaveFileObject(string path)
{
header = new WavHeader();
using (FileStream fs = new FileStream(path, FileMode.Open))
using (BinaryReader br = new BinaryReader(fs))
{
try
{
header.riff = br.ReadBytes(4);
header.size = br.ReadUInt32();
header.wavID = br.ReadBytes(4);
byte[] temp = br.ReadBytes(4);
string chunk = System.Text.Encoding.UTF8.GetString(temp);
if (chunk != "fmt ")
{
byte[] junk = br.ReadBytes(36);
}
else
{
header.fmtID = temp;
}
header.fmtSize = br.ReadUInt32();
header.format = br.ReadUInt16();
header.channels = br.ReadUInt16();
header.sampleRate = br.ReadUInt32();
header.bytePerSec = br.ReadUInt32();
header.blockSize = br.ReadUInt16();
header.bit = br.ReadUInt16();
header.dataID = br.ReadBytes(4);
header.dataSize = br.ReadUInt32();
if (header.bit == 16)
{
soundData = new List <short>();
for (int i = 0; i < header.dataSize / (header.bit / 8); i++)
{
soundData.Add(br.ReadInt16());
//Debug.Log(soundData[i]);
}
}
if (header.bit == 32)
{
soundData = new List <uint>();
for (int i = 0; i < header.dataSize / (header.bit / 8); i++)
{
soundData.Add(br.ReadUInt32());
}
}
if (header.bit == 64)
{
soundData = new List <double>();
for (int i = 0; i < header.dataSize / (header.bit / 8); i++)
{
soundData.Add(br.ReadDouble());
}
}
}
catch (Exception e)
{
Console.WriteLine(e.Message);
throw;
}
finally
{
if (br != null)
{
br.Close();
}
if (fs != null)
{
fs.Close();
}
}
}
}
public WaveFileObject[] ToWaveChunksWithOverlaps(int ms, WaveFileObject obj)
{
double secs = ms / 1000d;
long chunkSamples = (long)(obj.header.sampleRate * secs * obj.header.channels);
long chunkCount = ((obj.soundData.Count / chunkSamples) * 2) - 2;
WaveFileObject[] waves = new WaveFileObject[chunkCount];
int osIndex = 0;
//Debug.Log("chunkCount " + chunkCount);
Debug.Log("chunkSamples " + chunkSamples);
//Debug.Log("sampleRate " + obj.header.sampleRate);
//Debug.Log("size " + obj.header.size);
//Debug.Log("Block size " + obj.header.blockSize);
//Debug.Log("Block size " + obj.header.bit);
Debug.Log("starting waves");
for (int i = 0; i < chunkCount; i++)
{
waves[i] = new WaveFileObject();
WavHeader tempHeader = header;
if (header.bit == 16)
{
tempHeader.dataSize = (uint)chunkSamples * 2;
tempHeader.blockSize = 2;
waves[i].soundData = new List <short>();
}
if (header.bit == 32)
{
tempHeader.dataSize = (uint)chunkSamples * 4;
tempHeader.blockSize = 4;
waves[i].soundData = new List <uint>();
}
if (header.bit == 64)
{
tempHeader.dataSize = (uint)chunkSamples * 8;
tempHeader.blockSize = 8;
waves[i].soundData = new List <double>();
}
waves[i].header = tempHeader;
}
for (int i = 0; i < chunkCount; i++)
{
//Debug.Log("Chunk count: " + i + " / " + chunkCount);
//Debug.Log("osIndex : " + osIndex);
//Debug.Log("soundDataCount : " + obj.soundData.Count);
for (int j = 0; j < chunkSamples; j++)
{
if (!IsOdd(i))
{
waves[i].soundData.Add(obj.soundData[osIndex]);
//Debug.Log(obj.soundData[osIndex]);
osIndex++;
}
else
{
waves[i].soundData.Add(obj.soundData[osIndex + j - (int)(chunkSamples * .5)]);
}
}
}
Debug.Log("returning waves");
return(waves);
}
public WaveFileObject(WavHeader header, IList soundData)
{
this.header = header;
this.soundData = soundData;
}
public static void WriteWaveFile(double[] data, string path)
{
WavHeader header = new WavHeader
{
riff = new byte[4] {
82, 73, 70, 70
},
size = 36 + (uint)data.Length * 2,
wavID = new byte[4] {
87, 65, 86, 69
},
fmtID = new byte[4] {
102, 109, 116, 32
},
fmtSize = 16,
format = 1,
channels = 1,
sampleRate = 44100,
bytePerSec = 176400,
blockSize = 8,
bit = 16,
dataID = new byte[4] {
100, 97, 116, 97
},
dataSize = (uint)data.Length * 2
};
using (FileStream fs = new FileStream(path, FileMode.Create, FileAccess.Write))
using (BinaryWriter bw = new BinaryWriter(fs))
{
try
{
bw.Write(header.riff);
bw.Write(header.size);
bw.Write(header.wavID);
bw.Write(header.fmtID);
bw.Write(header.fmtSize);
bw.Write(header.format);
bw.Write(header.channels);
bw.Write(header.sampleRate);
bw.Write(header.bytePerSec);
bw.Write(header.blockSize);
bw.Write(header.bit);
bw.Write(header.dataID);
bw.Write(header.dataSize);
if (header.bit == 16)
{
for (int i = 0; i < header.dataSize / header.blockSize; i++)
{
if (i < data.Length)
{
bw.Write((short)data[i]);
}
else
{
bw.Write(0);
}
}
}
}
finally
{
if (bw != null)
{
bw.Close();
}
if (fs != null)
{
fs.Close();
}
}
}
return;
}
public WaveFileObject(WavHeader header)
{
this.header = header;
}
private void WriteWavHeader(int length)
{
FMOD.SOUND_TYPE type = FMOD.SOUND_TYPE.UNKNOWN;
FMOD.SOUND_FORMAT format = FMOD.SOUND_FORMAT.NONE;
int channels = 0, bits = 0, temp1 = 0;
float rate = 0.0f;
float temp = 0.0f;
if (sound == null)
{
return;
}
sound.getFormat(ref type, ref format, ref channels, ref bits);
sound.getDefaults(ref rate, ref temp, ref temp, ref temp1);
fs.Seek(0, SeekOrigin.Begin);
FmtChunk fmtChunk = new FmtChunk();
DataChunk dataChunk = new DataChunk();
WavHeader wavHeader = new WavHeader();
RiffChunk riffChunk = new RiffChunk();
fmtChunk.chunk = new RiffChunk();
fmtChunk.chunk.id = new char[4];
fmtChunk.chunk.id[0] = 'f';
fmtChunk.chunk.id[1] = 'm';
fmtChunk.chunk.id[2] = 't';
fmtChunk.chunk.id[3] = ' ';
fmtChunk.chunk.size = Marshal.SizeOf(fmtChunk) - Marshal.SizeOf(riffChunk);
fmtChunk.wFormatTag = 1;
fmtChunk.nChannels = (ushort)channels;
fmtChunk.nSamplesPerSec = (uint)rate;
fmtChunk.nAvgBytesPerSec = (uint)(rate * channels * bits / 8);
fmtChunk.nBlockAlign = (ushort)(1 * channels * bits / 8);
fmtChunk.wBitsPerSample = (ushort)bits;
dataChunk.chunk = new RiffChunk();
dataChunk.chunk.id = new char[4];
dataChunk.chunk.id[0] = 'd';
dataChunk.chunk.id[1] = 'a';
dataChunk.chunk.id[2] = 't';
dataChunk.chunk.id[3] = 'a';
dataChunk.chunk.size = (int)length;
wavHeader.chunk = new RiffChunk();
wavHeader.chunk.id = new char[4];
wavHeader.chunk.id[0] = 'R';
wavHeader.chunk.id[1] = 'I';
wavHeader.chunk.id[2] = 'F';
wavHeader.chunk.id[3] = 'F';
wavHeader.chunk.size = (int)(Marshal.SizeOf(fmtChunk) + Marshal.SizeOf(riffChunk) + length);
wavHeader.rifftype = new char[4];
wavHeader.rifftype[0] = 'W';
wavHeader.rifftype[1] = 'A';
wavHeader.rifftype[2] = 'V';
wavHeader.rifftype[3] = 'E';
/*
Write out the WAV header.
*/
IntPtr wavHeaderPtr = Marshal.AllocHGlobal(Marshal.SizeOf(wavHeader));
IntPtr fmtChunkPtr = Marshal.AllocHGlobal(Marshal.SizeOf(fmtChunk));
IntPtr dataChunkPtr = Marshal.AllocHGlobal(Marshal.SizeOf(dataChunk));
byte []wavHeaderBytes = new byte[Marshal.SizeOf(wavHeader)];
byte []fmtChunkBytes = new byte[Marshal.SizeOf(fmtChunk)];
byte []dataChunkBytes = new byte[Marshal.SizeOf(dataChunk)];
Marshal.StructureToPtr(wavHeader, wavHeaderPtr, false);
Marshal.Copy(wavHeaderPtr, wavHeaderBytes, 0, Marshal.SizeOf(wavHeader));
Marshal.StructureToPtr(fmtChunk, fmtChunkPtr, false);
Marshal.Copy(fmtChunkPtr, fmtChunkBytes, 0, Marshal.SizeOf(fmtChunk));
Marshal.StructureToPtr(dataChunk, dataChunkPtr, false);
Marshal.Copy(dataChunkPtr, dataChunkBytes, 0, Marshal.SizeOf(dataChunk));
fs.Write(wavHeaderBytes, 0, Marshal.SizeOf(wavHeader));
fs.Write(fmtChunkBytes, 0, Marshal.SizeOf(fmtChunk));
fs.Write(dataChunkBytes, 0, Marshal.SizeOf(dataChunk));
}
private void SaveToWav()
{
FileStream fs = null;
int channels = 0, bits = 0;
float rate = 0;
IntPtr ptr1 = new IntPtr(), ptr2 = new IntPtr();
uint lenbytes = 0, len1 = 0, len2 = 0;
FMOD.SOUND_TYPE type = FMOD.SOUND_TYPE.WAV;
FMOD.SOUND_FORMAT format = FMOD.SOUND_FORMAT.NONE;
int temp1 = 0;
float temp3 = 0;
if (sound == null)
{
return;
}
sound.getFormat(ref type, ref format, ref channels, ref bits);
sound.getDefaults(ref rate, ref temp3, ref temp3, ref temp1);
sound.getLength(ref lenbytes, FMOD.TIMEUNIT.PCMBYTES);
FmtChunk fmtChunk = new FmtChunk();
DataChunk dataChunk = new DataChunk();
WavHeader wavHeader = new WavHeader();
RiffChunk riffChunk = new RiffChunk();
fmtChunk.chunk = new RiffChunk();
fmtChunk.chunk.id = new char[4];
fmtChunk.chunk.id[0] = 'f';
fmtChunk.chunk.id[1] = 'm';
fmtChunk.chunk.id[2] = 't';
fmtChunk.chunk.id[3] = ' ';
fmtChunk.chunk.size = Marshal.SizeOf(fmtChunk) - Marshal.SizeOf(riffChunk);
fmtChunk.wFormatTag = 1;
fmtChunk.nChannels = (ushort)channels;
fmtChunk.nSamplesPerSec = (uint)rate;
fmtChunk.nAvgBytesPerSec = (uint)(rate * channels * bits / 8);
fmtChunk.nBlockAlign = (ushort)(1 * channels * bits / 8);
fmtChunk.wBitsPerSample = (ushort)bits;
dataChunk.chunk = new RiffChunk();
dataChunk.chunk.id = new char[4];
dataChunk.chunk.id[0] = 'd';
dataChunk.chunk.id[1] = 'a';
dataChunk.chunk.id[2] = 't';
dataChunk.chunk.id[3] = 'a';
dataChunk.chunk.size = (int)lenbytes;
wavHeader.chunk = new RiffChunk();
wavHeader.chunk.id = new char[4];
wavHeader.chunk.id[0] = 'R';
wavHeader.chunk.id[1] = 'I';
wavHeader.chunk.id[2] = 'F';
wavHeader.chunk.id[3] = 'F';
wavHeader.chunk.size = (int)(Marshal.SizeOf(fmtChunk) + Marshal.SizeOf(riffChunk) + lenbytes);
wavHeader.rifftype = new char[4];
wavHeader.rifftype[0] = 'W';
wavHeader.rifftype[1] = 'A';
wavHeader.rifftype[2] = 'V';
wavHeader.rifftype[3] = 'E';
fs = new FileStream("record.wav", FileMode.Create, FileAccess.Write);
/*
* Write out the WAV header.
*/
IntPtr wavHeaderPtr = Marshal.AllocHGlobal(Marshal.SizeOf(wavHeader));
IntPtr fmtChunkPtr = Marshal.AllocHGlobal(Marshal.SizeOf(fmtChunk));
IntPtr dataChunkPtr = Marshal.AllocHGlobal(Marshal.SizeOf(dataChunk));
byte [] wavHeaderBytes = new byte[Marshal.SizeOf(wavHeader)];
byte [] fmtChunkBytes = new byte[Marshal.SizeOf(fmtChunk)];
byte [] dataChunkBytes = new byte[Marshal.SizeOf(dataChunk)];
Marshal.StructureToPtr(wavHeader, wavHeaderPtr, false);
Marshal.Copy(wavHeaderPtr, wavHeaderBytes, 0, Marshal.SizeOf(wavHeader));
Marshal.StructureToPtr(fmtChunk, fmtChunkPtr, false);
Marshal.Copy(fmtChunkPtr, fmtChunkBytes, 0, Marshal.SizeOf(fmtChunk));
Marshal.StructureToPtr(dataChunk, dataChunkPtr, false);
Marshal.Copy(dataChunkPtr, dataChunkBytes, 0, Marshal.SizeOf(dataChunk));
fs.Write(wavHeaderBytes, 0, Marshal.SizeOf(wavHeader));
fs.Write(fmtChunkBytes, 0, Marshal.SizeOf(fmtChunk));
fs.Write(dataChunkBytes, 0, Marshal.SizeOf(dataChunk));
/*
* Lock the sound to get access to the raw data.
*/
sound.@lock(0, lenbytes, ref ptr1, ref ptr2, ref len1, ref len2);
/*
* Write it to disk.
*/
byte [] rawdata = new byte[len1];
Marshal.Copy(ptr1, rawdata, 0, (int)len1);
fs.Write(rawdata, 0, (int)len1);
/*
* Unlock the sound to allow FMOD to use it again.
*/
sound.unlock(ptr1, ptr2, len1, len2);
fs.Close();
MessageBox.Show("Written to record.wav");
}
