public SampleDataChunk(RiffChunk chunk)
{
string header = chunk.ReadChunkID();
if(header != "sdta")
{
throw new InvalidDataException(String.Format("Not a sample data chunk ({0})",header));
}
sampleData = chunk.GetData();
}
/// <summary>
/// Gets the data for the specified chunk
/// </summary>
public byte[] GetChunkData(RiffChunk chunk)
{
long oldPosition = waveStream.Position;
waveStream.Position = chunk.StreamPosition;
byte[] data = new byte[chunk.Length];
waveStream.Read(data, 0, data.Length);
waveStream.Position = oldPosition;
return(data);
}
private static void PlaylistChunkReadProcedure(RiffChunk chunk, BinaryReader reader)
{
var playlistSegmentCount = reader.ReadUInt32();
chunk.Children.Add(new UInt32Component(playlistSegmentCount));
for (var i = 0; i < playlistSegmentCount; i++)
{
chunk.Children.Add(new PlaylistSegmentComponent(reader));
}
}
private static void CueChunkReadProcedure(RiffChunk chunk, BinaryReader reader)
{
var cuePointCount = reader.ReadUInt32();
chunk.Children.Add(new UInt32Component(cuePointCount));
for (var i = 0; i < cuePointCount; i++)
{
chunk.Children.Add(new CuePointComponent(reader));
}
}
private static DlsInstrument?ReadDlsInstrument(RiffChunk insChunk)
{
var isHeaderSet = false;
byte msb = 0, lsb = 0, patch = 0;
var isPercussion = false;
var regions = new List <DlsRegion>();
var id = default(Guid?);
var info = new DlsInfo();
var articulatorList = (IReadOnlyList <DlsArticulator>) new DlsArticulator[0];
foreach (var insSubchunk in insChunk.ReadList())
{
switch (insSubchunk.Name)
{
case "dlid":
id = ReadDlsId(insSubchunk);
break;
case "insh":
isHeaderSet = true;
insSubchunk.ReadUInt32(); // NumRegions
var bank = insSubchunk.ReadUInt32();
lsb = (byte)bank;
msb = (byte)(bank >> 8);
isPercussion = (bank & 0x8000000u) != 0;
patch = (byte)insSubchunk.ReadUInt32();
break;
case "lrgn":
regions.AddRange(
from lrgnSubchunk in insSubchunk.ReadList()
where lrgnSubchunk.Name == "rgn "
let region = ReadDlsRegion(lrgnSubchunk)
where region != null
select region.Value);
break;
case "lart":
articulatorList = ReadDlsArticulatorList(insSubchunk);
break;
case "INFO":
info = ReadDlsInfo(insSubchunk);
break;
}
}
if (!isHeaderSet)
{
return(null);
}
return(new DlsInstrument(id, info, msb, lsb, patch, isPercussion, regions, articulatorList));
}
public void LoadStream(Stream s)
{
readCounter = 0;
BinaryReader br = new BinaryReader(s);
RiffChunk chunk = ReadChunk(br);
if (chunk.tag != "RIFF")
{
throw new FormatException("can't recognize riff chunk");
}
riff = (RiffContainer)chunk;
}
RiffChunk ReadWaveFile(string path)
{
RiffChunk riffChunk;
using (var fs = new FileStream(path, FileMode.Open, FileAccess.Read))
using (var reader = new BinaryReader(fs))
{
riffChunk = (RiffChunk)WaveFileChunkReader.Read(reader);
}
return(riffChunk);
}
void OnGUI()
{
var selectedClip = Selection.activeObject as AudioClip;
if (selectedClip == null)
{
return;
}
var path = AssetDatabase.GetAssetPath(selectedClip);
if (string.IsNullOrEmpty(path))
{
return;
}
if (path != previousPath || riffChunk == null)
{
riffChunk = ReadWaveFile(path);
previousPath = path;
}
var samplerChunk = riffChunk.Chunks.OfType <SamplerChunk>().FirstOrDefault();
if (samplerChunk == null)
{
samplerChunk = new SamplerChunk();
riffChunk.Chunks.Add(samplerChunk);
}
var sampleLoop = samplerChunk.SampleLoops.FirstOrDefault();
if (sampleLoop == null)
{
sampleLoop = new SamplerChunk.SampleLoop();
samplerChunk.SampleLoops.Add(sampleLoop);
}
sampleLoop.LoopStart = EditorGUILayout.IntField("loop start (samples)", sampleLoop.LoopStart);
sampleLoop.LoopEnd = EditorGUILayout.IntField("loop end (samples)", sampleLoop.LoopEnd);
if (GUILayout.Button("Save"))
{
using (var fs = new FileStream(path, FileMode.OpenOrCreate, FileAccess.Write))
using (var writer = new BinaryWriter(fs))
{
riffChunk.Write(writer);
}
AssetDatabase.ImportAsset(path, ImportAssetOptions.ForceUpdate);
}
}
/// <summary>
/// The class will pares all the data in advance while constructing
/// </summary>
/// <param name="stream">The input stream of the wave file</param>
/// <param name="stringEncoding">Charset of the strings in the file</param>
public WavReader(Stream stream, Encoding stringEncoding)
{
using (BinaryReader binaryReader = new BinaryReader(stream))
{
IChunk chunk = NextChunk(binaryReader, stringEncoding);
if (chunk.Descriptor.ChunkId != "RIFF")
{
throw new FormatNotSupportedException();
}
Riff = (RiffChunk)chunk;
}
}
private static DlsRegion?ReadDlsRegion(RiffChunk rgnChunk)
{
var isHeaderSet = false;
var rangeKeyLow = default(ushort);
var rangeKeyHigh = default(ushort);
var rangeVelocityLow = default(ushort);
var rangeVelocityHigh = default(ushort);
var selfNonExclusive = false;
var keyGroup = default(ushort);
var waveSample = default(DlsWaveSample?);
var waveLink = default(DlsWaveLink);
var articulatorList = (IReadOnlyList <DlsArticulator>) new DlsArticulator[0];
foreach (var rgnSubchunk in rgnChunk.ReadList())
{
switch (rgnSubchunk.Name)
{
case "rgnh":
isHeaderSet = true;
rangeKeyLow = rgnSubchunk.ReadUInt16();
rangeKeyHigh = rgnSubchunk.ReadUInt16();
rangeVelocityLow = rgnSubchunk.ReadUInt16();
rangeVelocityHigh = rgnSubchunk.ReadUInt16();
selfNonExclusive = rgnSubchunk.ReadUInt16() == 1;
keyGroup = rgnSubchunk.ReadUInt16();
break;
case "wsmp":
waveSample = ReadDlsWaveSample(rgnSubchunk);
break;
case "wlnk":
waveLink = new DlsWaveLink(
options: (DlsWaveLinkOptions)rgnSubchunk.ReadUInt16(),
phaseGroup: rgnSubchunk.ReadUInt16(),
channels: rgnSubchunk.ReadUInt32(),
tableIndex: rgnSubchunk.ReadUInt32());
break;
case "lart":
articulatorList = ReadDlsArticulatorList(rgnSubchunk);
break;
}
}
if (!isHeaderSet)
{
return(null);
}
return(new DlsRegion(rangeKeyLow, rangeKeyHigh, rangeVelocityLow, rangeVelocityHigh, selfNonExclusive, keyGroup, waveSample, waveLink, articulatorList));
}
private static void SamplerChunkReadProcedure(RiffChunk chunk, BinaryReader reader)
{
var samplerComponent = new SamplerComponent(reader);
chunk.Children.Add(samplerComponent);
for (var i = 0; i < samplerComponent.LoopCount; i++)
{
chunk.Children.Add(new SampleLoopComponent(reader));
}
if (samplerComponent.ExtraDataSize > 0)
{
chunk.Children.Add(new ByteArrayComponent(reader, (int)samplerComponent.ExtraDataSize));
}
}
private static void FactChunkReadProcedure(RiffChunk chunk, BinaryReader reader)
{
var factCount = (chunk.StreamIndicatedSize / 4);
for (var i = 0; i < factCount; i++)
{
chunk.Children.Add(new UInt32Component(reader));
}
// Skip any extra data that may exist (indicates existence of fact data that are not 4B in size)
var extraBytes = chunk.StreamIndicatedSize % 4;
if (extraBytes != 0)
{
reader.BaseStream.Seek(extraBytes % 4, SeekOrigin.Current);
}
}
private static DlsWaveFile?ReadDlsWaveFile(RiffChunk waveChunk)
{
var format = default(DlsWaveFormat);
var numChannels = default(ushort);
var samplesPerSecond = default(uint);
var avgBytesPerSec = default(uint);
var blockAlign = default(ushort);
var bitsPerSample = default(ushort?);
var data = default(byte[]);
var info = new DlsInfo();
var waveSample = default(DlsWaveSample?);
foreach (var waveSubchunk in waveChunk.ReadList())
{
switch (waveSubchunk.Name)
{
case "fmt ":
format = (DlsWaveFormat)waveSubchunk.ReadUInt16();
numChannels = waveSubchunk.ReadUInt16();
samplesPerSecond = waveSubchunk.ReadUInt32();
avgBytesPerSec = waveSubchunk.ReadUInt32();
blockAlign = waveSubchunk.ReadUInt16();
if (format == DlsWaveFormat.PCM)
{
bitsPerSample = waveSubchunk.ReadUInt16();
}
break;
case "data":
data = waveSubchunk.ReadAllBytes();
break;
case "INFO":
info = ReadDlsInfo(waveSubchunk);
break;
case "wsmp":
waveSample = ReadDlsWaveSample(waveSubchunk);
break;
}
}
return(new DlsWaveFile(format, numChannels, samplesPerSecond, avgBytesPerSec, blockAlign, bitsPerSample, data, waveSample, info));
}
private static void DescribeChunk(RiffChunk chunk, StringBuilder stringBuilder, byte[] data)
{
switch (chunk.IdentifierAsString)
{
case "strc":
DescribeStrc(stringBuilder, data);
break;
default:
{
int n = 0;
foreach (byte b in data)
{
stringBuilder.AppendFormat("{0:X2} ", b);
if (++n % 8 == 0)
{
stringBuilder.Append("\r\n");
}
}
stringBuilder.Append("\r\n");
}
break;
}
}
private static void WaveListChunkValidationProcedure(RiffChunk chunk, ref ValidationResult result)
{
var listChunk = chunk as ListChunk;
if (listChunk == null)
throw new FormatException("\"chunk\" must be a ListChunk");
}
private static void SilentChunkValidationProcedure(RiffChunk chunk, ref ValidationResult result)
{
}
private static void ValidateChunk(RiffChunk chunk, ref ValidationResult result)
{
}
private static void ReadChunk(RiffChunk chunk, BinaryReader reader)
{
}
private static void SamplerChunkWriteProcedure(RiffChunk chunk, BinaryWriter writer)
{
}
private bool _ReadV3(BinaryReader r)
{
RiffChunk chunk = new RiffChunk();
char[] wavchunk;
FormatChunk fmt;
bool hasfmt;
WavpackHeader3 wvh3 = new WavpackHeader3();
bool result = false;
hasfmt = false;
// read and evaluate header
chunk.Reset();
chunk.id = r.ReadChars(4);
chunk.size = r.ReadUInt32();
wavchunk = r.ReadChars(4);
if (!StreamUtils.StringEqualsArr("WAVE", wavchunk))
{
return(result);
}
// start looking for chunks
chunk.Reset();
while (r.BaseStream.Position < r.BaseStream.Length)
{
chunk.id = r.ReadChars(4);
chunk.size = r.ReadUInt32();
if (chunk.size <= 0)
{
break;
}
if (StreamUtils.StringEqualsArr("fmt ", chunk.id)) // Format chunk found read it
{
if (chunk.size >= 16 /*sizeof(fmt_chunk)*/)
{
fmt.wformattag = r.ReadUInt16();
fmt.wchannels = r.ReadUInt16();
fmt.dwsamplespersec = r.ReadUInt32();
fmt.dwavgbytespersec = r.ReadUInt32();
fmt.wblockalign = r.ReadUInt16();
fmt.wbitspersample = r.ReadUInt16();
hasfmt = true;
result = true;
formatTag = fmt.wformattag;
channelsArrangement = ChannelsArrangements.GuessFromChannelNumber(fmt.wchannels);
sampleRate = (int)fmt.dwsamplespersec;
bits = fmt.wbitspersample;
bitrate = (double)fmt.dwavgbytespersec * 8;
}
else
{
break;
}
}
else
{
if ((StreamUtils.StringEqualsArr("data", chunk.id)) && hasfmt)
{
wvh3.Reset();
wvh3.ckID = r.ReadChars(4);
wvh3.ckSize = r.ReadUInt32();
wvh3.version = r.ReadUInt16();
wvh3.bits = r.ReadUInt16();
wvh3.flags = r.ReadUInt16();
wvh3.shift = r.ReadUInt16();
wvh3.total_samples = r.ReadUInt32();
wvh3.crc = r.ReadUInt32();
wvh3.crc2 = r.ReadUInt32();
wvh3.extension = r.ReadChars(4);
wvh3.extra_bc = r.ReadByte();
wvh3.extras = r.ReadChars(3);
if (StreamUtils.StringEqualsArr("wvpk", wvh3.ckID)) // wavpack header found
{
result = true;
version = wvh3.version;
channelsArrangement = ChannelsArrangements.GuessFromChannelNumber(2 - (wvh3.flags & 1));
samples = wvh3.total_samples;
codecFamily = AudioDataIOFactory.CF_LOSSLESS;
// Encoder guess
if (wvh3.bits > 0)
{
if ((wvh3.flags & NEW_HIGH_FLAG_v3) > 0)
{
encoder = "hybrid";
if ((wvh3.flags & WVC_FLAG_v3) > 0)
{
encoder += " lossless";
}
else
{
encoder += " lossy";
codecFamily = AudioDataIOFactory.CF_LOSSY;
}
if ((wvh3.flags & EXTREME_DECORR_v3) > 0)
{
encoder = encoder + " (high)";
}
}
else
{
if ((wvh3.flags & (HIGH_FLAG_v3 | FAST_FLAG_v3)) == 0)
{
encoder = (wvh3.bits + 3).ToString() + "-bit lossy";
codecFamily = AudioDataIOFactory.CF_LOSSY;
}
else
{
encoder = (wvh3.bits + 3).ToString() + "-bit lossy";
codecFamily = AudioDataIOFactory.CF_LOSSY;
if ((wvh3.flags & HIGH_FLAG_v3) > 0)
{
encoder += " high";
}
else
{
encoder += " fast";
}
}
}
}
else
{
if ((wvh3.flags & HIGH_FLAG_v3) == 0)
{
encoder = "lossless (fast mode)";
}
else
{
if ((wvh3.flags & EXTREME_DECORR_v3) > 0)
{
encoder = "lossless (high mode)";
}
else
{
encoder = "lossless";
}
}
}
if (sampleRate <= 0)
{
sampleRate = 44100;
}
duration = (double)wvh3.total_samples * 1000.0 / sampleRate;
if (duration > 0)
{
bitrate = 8.0 * (sizeInfo.FileSize - tagSize - (double)wvh3.ckSize) / duration;
}
}
break;
}
else // not a wv file
{
break;
}
}
} // while
return(result);
}
private static void PlaylistChunkReadProcedure(RiffChunk chunk, BinaryReader reader)
{
var playlistSegmentCount = reader.ReadUInt32();
chunk.Children.Add(new UInt32Component(playlistSegmentCount));
for (var i = 0; i < playlistSegmentCount; i++)
{
chunk.Children.Add(new PlaylistSegmentComponent(reader));
}
}
private static void WriteChunk(RiffChunk chunk, BinaryWriter writer)
{
}
private static void LabeledTextChunkReadProcedure(RiffChunk chunk, BinaryReader reader)
{
chunk.Children.Add(new LabeledTextComponent(reader));
if (chunk.StreamIndicatedSize > 20)
chunk.Children.Add(new TextComponent(reader));
}
private static void SilentChunkReadProcedure(RiffChunk chunk, BinaryReader reader)
{
var silentSampleCount = reader.ReadUInt32();
chunk.Children.Add(new UInt32Component(silentSampleCount));
}
private static void LabeledTextChunkWriteProcedure(RiffChunk chunk, BinaryWriter writer)
{
}
private static void ValidateChunk(RiffChunk chunk, ref ValidationResult result)
{
}
internal PresetsChunk(RiffChunk chunk)
{
string header = chunk.ReadChunkID();
if(header != "pdta")
{
throw new InvalidDataException(String.Format("Not a presets data chunk ({0})",header));
}
RiffChunk c;
while((c = chunk.GetNextSubChunk()) != null)
{
switch(c.ChunkID) {
case "PHDR":
case "phdr":
c.GetDataAsStructureArray(presetHeaders);
break;
case "PBAG":
case "pbag":
c.GetDataAsStructureArray(presetZones);
break;
case "PMOD":
case "pmod":
c.GetDataAsStructureArray(presetZoneModulators);
break;
case "PGEN":
case "pgen":
c.GetDataAsStructureArray(presetZoneGenerators);
break;
case "INST":
case "inst":
c.GetDataAsStructureArray(instruments);
break;
case "IBAG":
case "ibag":
c.GetDataAsStructureArray(instrumentZones);
break;
case "IMOD":
case "imod":
c.GetDataAsStructureArray(instrumentZoneModulators);
break;
case "IGEN":
case "igen":
c.GetDataAsStructureArray(instrumentZoneGenerators);
break;
case "SHDR":
case "shdr":
c.GetDataAsStructureArray(sampleHeaders);
break;
default:
throw new InvalidDataException(String.Format("Unknown chunk type {0}", c.ChunkID));
}
}
// now link things up
instrumentZoneGenerators.Load(sampleHeaders.SampleHeaders);
instrumentZones.Load(instrumentZoneModulators.Modulators,instrumentZoneGenerators.Generators);
instruments.LoadZones(instrumentZones.Zones);
presetZoneGenerators.Load(instruments.Instruments);
presetZones.Load(presetZoneModulators.Modulators,presetZoneGenerators.Generators);
presetHeaders.LoadZones(presetZones.Zones);
sampleHeaders.RemoveEOS();
}
private static void InstrumentChunkReadProcedure(RiffChunk chunk, BinaryReader reader)
{
chunk.Children.Add(new InstrumentComponent(reader));
}
private static void WriteChunk(RiffChunk chunk, BinaryWriter writer)
{
}
private static void LabeledTextChunkWriteProcedure(RiffChunk chunk, BinaryWriter writer)
{
}
private static void PlaylistChunkWriteProcedure(RiffChunk chunk, BinaryWriter writer)
{
}
private static void DataChunkReadProcedure(RiffChunk chunk, BinaryReader reader)
{
chunk.Children.Add(new RawDataComponent(reader, (int)chunk.StreamIndicatedSize));
}
private static void InstrumentChunkReadProcedure(RiffChunk chunk, BinaryReader reader)
{
chunk.Children.Add(new InstrumentComponent(reader));
}
private static void SamplerChunkWriteProcedure(RiffChunk chunk, BinaryWriter writer)
{
}
private static void LabeledTextChunkValidationProcedure(RiffChunk chunk, ref ValidationResult result)
{
}
private static void SilentChunkWriteProcedure(RiffChunk chunk, BinaryWriter writer)
{
}
private static void NoteChunkReadProcedure(RiffChunk chunk, BinaryReader reader)
{
var cueId = reader.ReadUInt32();
chunk.Children.Add(new UInt32Component(cueId));
chunk.Children.Add(new TextComponent(reader));
}
private static void LabeledTextChunkValidationProcedure(RiffChunk chunk, ref ValidationResult result)
{
}
private static void PlaylistChunkWriteProcedure(RiffChunk chunk, BinaryWriter writer)
{
}
private static void SilentChunkValidationProcedure(RiffChunk chunk, ref ValidationResult result)
{
}
private static void SamplerChunkReadProcedure(RiffChunk chunk, BinaryReader reader)
{
var samplerComponent = new SamplerComponent(reader);
chunk.Children.Add(samplerComponent);
for (var i = 0; i < samplerComponent.LoopCount; i++)
{
chunk.Children.Add(new SampleLoopComponent(reader));
}
if (samplerComponent.ExtraDataSize > 0)
chunk.Children.Add(new ByteArrayComponent(reader, (int) samplerComponent.ExtraDataSize));
}
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");
}
private static void SilentChunkReadProcedure(RiffChunk chunk, BinaryReader reader)
{
var silentSampleCount = reader.ReadUInt32();
chunk.Children.Add(new UInt32Component(silentSampleCount));
}
private static DlsInfo ReadDlsInfo(RiffChunk infoChunk)
{
var archivalLocation = (string)null;
var artist = (string)null;
var commissioned = (string)null;
var comments = (string)null;
var copyright = (string)null;
var creationDate = (DateTime?)null;
var engineer = (string)null;
var genre = (string)null;
var keywords = (string)null;
var medium = (string)null;
var name = (string)null;
var product = (string)null;
var subject = (string)null;
var software = (string)null;
var source = (string)null;
var sourceForm = (string)null;
var technician = (string)null;
foreach (var infoSubchunk in infoChunk.ReadList())
{
switch (infoSubchunk.Name)
{
case "IARL":
archivalLocation = infoSubchunk.ReadNullTerminatedString();
break;
case "IART":
artist = infoSubchunk.ReadNullTerminatedString();
break;
case "ICMS":
commissioned = infoSubchunk.ReadNullTerminatedString();
break;
case "ICMT":
comments = infoSubchunk.ReadNullTerminatedString();
break;
case "ICOP":
copyright = infoSubchunk.ReadNullTerminatedString();
break;
case "ICRD":
DateTime value;
if (DateTime.TryParse(infoSubchunk.ReadNullTerminatedString(), out value))
{
creationDate = value;
}
break;
case "IENG":
engineer = infoSubchunk.ReadNullTerminatedString();
break;
case "IGNR":
genre = infoSubchunk.ReadNullTerminatedString();
break;
case "IKEY":
keywords = infoSubchunk.ReadNullTerminatedString();
break;
case "IMED":
medium = infoSubchunk.ReadNullTerminatedString();
break;
case "INAM":
name = infoSubchunk.ReadNullTerminatedString();
break;
case "IPRD":
product = infoSubchunk.ReadNullTerminatedString();
break;
case "ISBJ":
subject = infoSubchunk.ReadNullTerminatedString();
break;
case "ISFT":
software = infoSubchunk.ReadNullTerminatedString();
break;
case "ISRC":
source = infoSubchunk.ReadNullTerminatedString();
break;
case "ISRF":
sourceForm = infoSubchunk.ReadNullTerminatedString();
break;
case "ITCH":
technician = infoSubchunk.ReadNullTerminatedString();
break;
}
}
return(new DlsInfo(
archivalLocation,
artist,
commissioned,
comments,
copyright,
creationDate,
engineer,
genre,
keywords,
medium,
name,
product,
subject,
software,
source,
sourceForm,
technician));
}
private static void SilentChunkWriteProcedure(RiffChunk chunk, BinaryWriter writer)
{
}
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 static void WaveListChunkReadProcedure(RiffChunk chunk, BinaryReader reader)
{
var listChunk = chunk as ListChunk;
if (listChunk == null)
throw new FormatException("\"chunk\" must be a ListChunk");
var procedureSets = new List<ProcedureSet>
{
new ProcedureSet((uint) WaveChunkId.Data,
DataChunkReadProcedure,
DataChunkWriteProcedure,
DataChunkValidationProcedure),
new ProcedureSet((uint) WaveChunkId.Silent,
SilentChunkReadProcedure,
SilentChunkWriteProcedure,
SilentChunkValidationProcedure)
};
AddSubchunkProcedures(listChunk, procedureSets.ToArray());
}
private static void CueChunkReadProcedure(RiffChunk chunk, BinaryReader reader)
{
var cuePointCount = reader.ReadUInt32();
chunk.Children.Add(new UInt32Component(cuePointCount));
for (var i = 0; i < cuePointCount; i++)
{
chunk.Children.Add(new CuePointComponent(reader));
}
}
private static void WaveListChunkWriteProcedure(RiffChunk chunk, BinaryWriter writer)
{
var listChunk = chunk as ListChunk;
if (listChunk == null)
throw new FormatException("\"chunk\" must be a ListChunk");
}
private static void DataChunkReadProcedure(RiffChunk chunk, BinaryReader reader)
{
chunk.Children.Add(new RawDataComponent(reader, (int) chunk.StreamIndicatedSize));
}
private Tuple<LabeledTextComponent, string> CreateLabelObject(RiffChunk chunk)
{
var labeledTextComponent = chunk.Children.OfType<LabeledTextComponent>().FirstOrDefault();
var textComponent = chunk.Children.OfType<TextComponent>().FirstOrDefault();
return textComponent != null
? new Tuple<LabeledTextComponent, string>(labeledTextComponent, textComponent.Text)
: new Tuple<LabeledTextComponent, string>(labeledTextComponent, null);
}
private static void FactChunkReadProcedure(RiffChunk chunk, BinaryReader reader)
{
var factCount = (chunk.StreamIndicatedSize/4);
for (var i = 0; i < factCount; i++)
{
chunk.Children.Add(new UInt32Component(reader));
}
// Skip any extra data that may exist (indicates existence of fact data that are not 4B in size)
var extraBytes = chunk.StreamIndicatedSize%4;
if (extraBytes != 0)
reader.BaseStream.Seek(extraBytes%4, SeekOrigin.Current);
}
public Sf2File(Stream stream)
{
// <SFBK-form> ; SoundFont 2 RIFF File Format
var sfbkChunk = new RiffChunk(stream);
using (var sfbkStream = sfbkChunk.GetStream()) {
// <SFBK-form> -> RIFF (‘sfbk’ ; RIFF form header
var sfbkId = StreamHelperLe.ReadString(sfbkStream, 4);
if (sfbkId != "sfbk")
{
throw new FileFormatException("Sf2.sfbkId", sfbkId, "sfbk");
}
// <INFO-list> ; Supplemental Information
var infoChunk = new RiffChunk(sfbkStream);
using (var infoStream = infoChunk.GetStream()) {
// <INFO-list> -> LIST (‘INFO’
var infoId = StreamHelperLe.ReadString(infoStream, 4);
if (infoId != "INFO")
{
throw new FileFormatException("Sf2.infoChunk.infoId", infoId, "INFO");
}
while (infoStream.Position < infoStream.Length)
{
var chunk = new RiffChunk(infoStream);
switch (chunk.Id)
{
case "ifil":
// <ifil-ck> ; Refers to the version of the Sound Font RIFF file
Version = BitConverter.ToUInt16(chunk.Data, 0) + "." + BitConverter.ToUInt16(chunk.Data, 2);
break;
case "isng":
// <isng-ck> ; Refers to the target Sound Engine
TargetSoundEngine = Encoding.UTF8.GetString(chunk.Data);
break;
case "INAM":
// <INAM-ck> ; Refers to the Sound Font Bank Name
Name = chunk.GetString();
break;
case "ICRD":
// [<ICRD-ck>] ; Refers to the Date of Creation of the Bank
DateOfCreation = chunk.GetString();
break;
case "IENG":
// [<IENG-ck>] ; Sound Designers and Engineers for the Bank
Enginners = chunk.GetString();
break;
case "IPRD":
// [<IPRD-ck>] ; Product for which the Bank was intended
Product = chunk.GetString();
break;
case "ICOP":
// [<ICOP-ck>] ; Contains any Copyright message
Copyright = chunk.GetString();
break;
case "ICMT":
// [<ICMT-ck>] ; Contains any Comments on the Bank
Comments = chunk.GetString();
break;
case "ISFT":
// [<ISFT-ck>] ; The SoundFont tools used to create and alter the bank
Tools = chunk.GetString();
break;
}
}
}
// <sdta-list> ; The Sample Binary Data
var sdtaChunk = new RiffChunk(sfbkStream);
using (var sdtaStream = sdtaChunk.GetStream()) {
// <sdta-ck> -> LIST (‘sdta’
var sdtaId = StreamHelperLe.ReadString(sdtaStream, 4);
if (sdtaId != "sdta")
{
throw new FileFormatException("Sf2.sdtaChunk.sdtaId", sdtaId, "sdta");
}
// [<smpl-ck>] ; The Digital Audio Samples for the upper 16 bits
if (sdtaStream.Position < sdtaStream.Length)
{
var smplChunk = new RiffChunk(sdtaStream);
SampleData = new short[smplChunk.Size / 2];
for (int i = 0; i < smplChunk.Size; i += 2)
{
SampleData[i / 2] = BitConverter.ToInt16(smplChunk.Data, i);
}
// [<sm24-ck>] ; The Digital Audio Samples for the lower 8 bits
if (sdtaStream.Position < sdtaStream.Length)
{
var sm24Chunk = new RiffChunk(sdtaStream);
SampleData24 = sm24Chunk.Data;
}
}
}
// <pdta-list> ; The Preset, Instrument, and Sample Header data
var pdtaChunk = new RiffChunk(sfbkStream);
using (var pdtaStream = pdtaChunk.GetStream()) {
// <pdta-ck> -> LIST (‘pdta’
var pdtaId = StreamHelperLe.ReadString(pdtaStream, 4);
if (pdtaId != "pdta")
{
throw new FileFormatException("Sf2.pdtaChunk.pdtaId", pdtaId, "pdta");
}
// <phdr-ck> ; The Preset Headers
var phdrChunk = new RiffChunk(pdtaStream);
using (var phdrStream = phdrChunk.GetStream()) {
var list = new List <PresetHeader>();
while (phdrStream.Position < phdrStream.Length)
{
list.Add(new PresetHeader(phdrStream));
}
PresetHeaders = list.ToArray();
}
// <pbag-ck> ; The Preset Index list
var pbagChunk = new RiffChunk(pdtaStream);
using (var pbagStream = pbagChunk.GetStream()) {
var list = new List <Bag>();
while (pbagStream.Position < pbagStream.Length)
{
list.Add(new Bag(pbagStream));
}
PresetBags = list.ToArray();
}
// <pmod-ck> ; The Preset Modulator list
var pmodChunk = new RiffChunk(pdtaStream);
using (var pmodStream = pmodChunk.GetStream()) {
var list = new List <Modulator>();
while (pmodStream.Position < pmodStream.Length)
{
list.Add(new Modulator(pmodStream));
}
PresetModulators = list.ToArray();
}
// <pgen-ck> ; The Preset Generator list
var pgenChunk = new RiffChunk(pdtaStream);
using (var pgenStream = pgenChunk.GetStream()) {
var list = new List <Generator>();
while (pgenStream.Position < pgenStream.Length)
{
list.Add(new Generator(pgenStream));
}
PresetGenerators = list.ToArray();
}
// <inst-ck> ; The Instrument Names and Indices
var instChunk = new RiffChunk(pdtaStream);
using (var instStream = instChunk.GetStream()) {
var list = new List <InstrumentHeader>();
while (instStream.Position < instStream.Length)
{
list.Add(new InstrumentHeader(instStream));
}
InstrumentHeaders = list.ToArray();
}
// <ibag-ck> ; The Instrument Index list
var ibagChunk = new RiffChunk(pdtaStream);
using (var ibagStream = ibagChunk.GetStream()) {
var list = new List <Bag>();
while (ibagStream.Position < ibagStream.Length)
{
list.Add(new Bag(ibagStream));
}
InstrumentBags = list.ToArray();
}
// <imod-ck> ; The Instrument Modulator list
var imodChunk = new RiffChunk(pdtaStream);
using (var imodStream = imodChunk.GetStream()) {
var list = new List <Modulator>();
while (imodStream.Position < imodStream.Length)
{
list.Add(new Modulator(imodStream));
}
InstrumentModulators = list.ToArray();
}
// <igen-ck> ; The Instrument Generator list
var igenChunk = new RiffChunk(pdtaStream);
using (var igenStream = igenChunk.GetStream()) {
var list = new List <Generator>();
while (igenStream.Position < igenStream.Length)
{
list.Add(new Generator(igenStream));
}
InstrumentGenerators = list.ToArray();
}
// <shdr-ck> ; The Sample Headers
var shdrChunk = new RiffChunk(pdtaStream);
using (var shdrStream = shdrChunk.GetStream()) {
var list = new List <SampleHeader>();
while (shdrStream.Position < shdrStream.Length)
{
list.Add(new SampleHeader(shdrStream));
}
SampleHeaders = list.ToArray();
}
}
}
Compile();
}
private static void ReadChunk(RiffChunk chunk, BinaryReader reader)
{
}
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));
}
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");
}
internal InfoChunk(RiffChunk chunk)
{
bool ifilPresent = false;
bool isngPresent = false;
bool INAMPresent = false;
if(chunk.ReadChunkID() != "INFO")
{
throw new InvalidDataException("Not an INFO chunk");
}
//this.chunk = chunk;
RiffChunk c;
while((c = chunk.GetNextSubChunk()) != null)
{
switch(c.ChunkID)
{
case "ifil":
ifilPresent = true;
verSoundFont = (SFVersion) c.GetDataAsStructure(new SFVersionBuilder());
break;
case "isng":
isngPresent = true;
waveTableSoundEngine = c.GetDataAsString();
break;
case "INAM":
INAMPresent = true;
bankName = c.GetDataAsString();
break;
case "irom":
dataROM = c.GetDataAsString();
break;
case "iver":
verROM = (SFVersion) c.GetDataAsStructure(new SFVersionBuilder());
break;
case "ICRD":
creationDate = c.GetDataAsString();
break;
case "IENG":
author = c.GetDataAsString();
break;
case "IPRD":
targetProduct = c.GetDataAsString();
break;
case "ICOP":
copyright = c.GetDataAsString();
break;
case "ICMT":
comments = c.GetDataAsString();
break;
case "ISFT":
tools = c.GetDataAsString();
break;
default:
throw new InvalidDataException(String.Format("Unknown chunk type {0}",c.ChunkID));
}
}
if(!ifilPresent)
{
throw new InvalidDataException("Missing SoundFont version information");
}
if(!isngPresent)
{
throw new InvalidDataException("Missing wavetable sound engine information");
}
if(!INAMPresent)
{
throw new InvalidDataException("Missing SoundFont name information");
}
}
private static void AssociatedDataListChunkReadProcedure(RiffChunk chunk, BinaryReader reader)
{
var listChunk = chunk as ListChunk;
if (listChunk == null)
throw new FormatException("\"chunk\" must be a ListChunk");
var procedureSets = new List<ProcedureSet>
{
new ProcedureSet((uint) WaveChunkId.Label,
LabelChunkReadProcedure,
LabelChunkWriteProcedure,
LabelChunkValidationProcedure),
new ProcedureSet((uint) WaveChunkId.Note,
NoteChunkReadProcedure,
NoteChunkWriteProcedure,
NoteChunkValidationProcedure),
new ProcedureSet((uint) WaveChunkId.LabeledText,
LabeledTextChunkReadProcedure,
LabeledTextChunkWriteProcedure,
LabeledTextChunkValidationProcedure)
};
AddSubchunkProcedures(listChunk, procedureSets.ToArray());
}
