GSF.Media
Represents the list info chunk in a WAVE media format file.
Represents the type ID and size for a "chunk" in a RIFF media format file.
The Resource Interchange File Format (RIFF) is a generic meta-format for storing data in tagged chunks.
It was introduced in 1991 by Microsoft and IBM, and was presented by Microsoft as the default format for
Windows 3.1 multimedia files. It is based on Electronic Arts's Interchange File Format, introduced in 1985,
the only difference being that multi-byte integers are in little-endian format, native to the 80x86 processor
series used in IBM PCs, rather than the big-endian format native to the 68k processor series used in Amiga and
Apple Macintosh computers, where IFF files were heavily used. (The specification for AIFF, the big-endian
analogue of RIFF, was published by Apple Computer in 1988.) The Microsoft implementation is mostly known
through file formats like AVI, ANI and WAV, which use the RIFF meta-format as their basis.
Some common RIFF file types:
File extension
Description
-
WAV
Windows audio file
-
AVI
Windows audio/video file
-
ANI
Animated Windows cursors
-
RMI
Windows RIFF MIDI file
-
CDR
CorelDRAW vector graphics file
The fixed byte length of a instance.
Constructor for derived classes used to initialize and validate properties.
Pre-parsed header.
Expected type ID.
Constructs a new for the given .
Expected type ID.
Generates a binary representation of this and copies it into the given buffer.
Buffer used to hold generated binary image of the source object.
0-based starting index in the to start writing.
The number of bytes written to the .
is null.
or is less than 0 -or-
and will exceed length.
Creates a copy of the .
A new copy of the .
Attempts to read the next RIFF chunk from the stream.
Source stream for next RIFF chunk.
Next RIFF chunk read from the stream.
RIFF chunk too small, media file corrupted.
Four character text identifer for RIFF chunk.
TypeID cannot be null.
TypeID must be extactly 4 characters in length.
Size of .
Gets the length of a consisting of type ID and chunk size (i.e., 8 bytes).
Type ID of a WAVE list chunk.
Reads a new WAVE list info section from the specified stream.
Pre-parsed header.
Source stream to read data from.
WAVE list info section is too small, wave file corrupted.
Gets list of info strings from list info blocks of this .
Provides a function signature for methods that damp an amplitude representing a
lowering of the acoustic pressure over time.
Sample index (0 to - 1).
Total period, in whole samples per second (i.e., seconds of time * ), over which to perform damping.
Number of samples per second, if useful for calculation.
Scaling factor in the range of zero to one used to damp an amplitude at the given sample index.
Defines a few damping functions.
Produces a natural damping curve very similar to that of a string based instrument - strong at
first and damping quickly over time from 1 to 0 over the .
Sample index (0 to - 1).
Total period, in whole samples per second (i.e., seconds of time * ), over which to perform damping.
Number of samples per second, if useful for calculation.
Scaling factor used to damp an amplitude at the given time.
This damping algorithm combines both the logarithmic and linear damping algoriths to
produce a very natural damping curve.
Produces a logarithmic damping curve - strong at first and damping quickly over time from 1 to 0 over the .
Sample index (0 to - 1).
Total period, in whole samples per second (i.e., seconds of time * ), over which to perform damping.
Number of samples per second, if useful for calculation.
Scaling factor used to damp an amplitude at the given time.
This damping would be similar to that of a note produced by a string based instrument.
Produces an inverse logarithmic damping curve - slowly damping with a sharp end from 1 to 0 over the .
Sample index (0 to - 1).
Total period, in whole samples per second (i.e., seconds of time * ), over which to perform damping.
Number of samples per second, if useful for calculation.
Scaling factor used to damp an amplitude at the given time.
This damping would be similar to that of a note produced on an electronic keyboard or a breath based instrument.
Produces a linear damping curve - damping with a perfect slope from 1 to 0 over the .
Sample index (0 to - 1).
Total period, in whole samples per second (i.e., seconds of time * ), over which to perform damping.
Number of samples per second, if useful for calculation.
Scaling factor used to damp an amplitude at the given time.
Produces a reverse linear damping curve - damping with a perfect slope from 0 to 1 over the .
Sample index (0 to - 1).
Total period, in whole samples per second (i.e., seconds of time * ), over which to perform damping.
Number of samples per second, if useful for calculation.
Scaling factor used to damp an amplitude at the given time.
This is just used for an interesting note effect.
Produces a sinusoidal damping curve oscillating from 1 to 0 to 1 over the .
Sample index (0 to - 1).
Total period, in whole samples per second (i.e., seconds of time * ), over which to perform damping.
Number of samples per second, if useful for calculation.
Scaling factor used to damp an amplitude at the given time.
This is just used for an interesting note effect.
Produces a damping signature that represents no damping over time.
Sample index (0 to - 1).
Total period, in whole samples per second (i.e., seconds of time * ), over which to perform damping.
Number of samples per second, if useful for calculation.
Returns a scalar of 1.0 regardless to time.
Zero damped sounds would be produced by synthetic sources such as an electronic keyboard.
Defines the relative intensity (i.e., volume) of a musical line.
No dynamic is defined.
pp - very soft.
p - soft.
mp - half soft as .
mf - half loud as .
This is the default dynamic level.
f - loud.
ff - very loud.
Defines the size of a musical measure as the number of beats per note value.
Creates a new musical measure defined as the number of beats per note value.
A representing the beats.
A representing the note value.
Creates a new musical measure defined as the number of beats per note value.
A representing the beats.
A representing the note value.
Creates a new musical measure defined as the number of beats per note value.
A representing the beats.
A representing the note value.
Validates that given note value will fit within this for specified beat.
Note value (i.e., length) to validate.
Beat within in measure where note value is trying to fit.
Validates that given note value will fit within this for specified beat.
Named note value to validate.
Beat within in measure where note value is trying to fit.
Dot length extensions to apply to named note value.
Validates that given note value will fit within this for specified beat.
Named note value to validate.
Beat within in measure where note value is trying to fit.
Dot length extensions to apply to named note value.
Gets or sets the number of beats per measure.
Get or sets the relative note value representing the basic pulse of the music.
Get or sets the note value, expressed in American form, representing the basic pulse of the music.
Get or sets the note value, expressed in British form, representing the basic pulse of the music.
This namespace is excluded from the official documentation TOC.
Defines fundamental musical note frequencies and methods to create them.
This example creates an in-memory wave file and adds notes to create a basic musical scale:
using System;
using GSF.Media;
using GSF.Media.Music;
static class Program
{
static void Main()
{
WaveFile waveFile = new WaveFile();
long samplePeriod = 6 * waveFile.SampleRate; // Compute total sample period
int totalNotes = 15; // Total notes to traverse
string noteID = Note.MiddleC; // Start note at middle C
double frequency = Note.GetFrequency(noteID); // Get frequency for middle C
bool reverse = false; // Traverse notes in reverse order
for (int sample = 0; sample samplePeriod; sample++)
{
// Change notes at even intervals within the sample period
if (sample > 0 (sample % (samplePeriod / totalNotes)) == 0)
{
if (reverse)
{
noteID = Note.GetPreviousID(noteID, false);
frequency = Note.GetFrequency(noteID);
}
else
{
noteID = Note.GetNextID(noteID, false);
frequency = Note.GetFrequency(noteID);
}
// Go back down the scale after C5
if (noteID == "C5")
reverse = true;
}
waveFile.AddSample(Timbre.BasicNote(frequency, sample, samplePeriod, waveFile.SampleRate) * 4500);
}
waveFile.Play();
Console.ReadKey();
}
}
Fundamental frequency for note C0.
Fundamental frequency for note C0#.
Fundamental frequency for note D0.
Fundamental frequency for note D0#.
Fundamental frequency for note E0.
Fundamental frequency for note F0.
Fundamental frequency for note F0#.
Fundamental frequency for note G0.
Fundamental frequency for note G0#.
Fundamental frequency for note A0.
Fundamental frequency for note A0#.
Fundamental frequency for note B0.
Fundamental frequency for note C1.
Fundamental frequency for note C1#.
Fundamental frequency for note D1.
Fundamental frequency for note D1#.
Fundamental frequency for note E1.
Fundamental frequency for note F1.
Fundamental frequency for note F1#.
Fundamental frequency for note G1.
Fundamental frequency for note G1#.
Fundamental frequency for note A1.
Fundamental frequency for note A1#.
Fundamental frequency for note B1.
Fundamental frequency for note C2.
Fundamental frequency for note C2#.
Fundamental frequency for note D2.
Fundamental frequency for note D2#.
Fundamental frequency for note E2.
Fundamental frequency for note F2.
Fundamental frequency for note F2#.
Fundamental frequency for note G2.
Fundamental frequency for note G2#.
Fundamental frequency for note A2.
Fundamental frequency for note A2#.
Fundamental frequency for note B2.
Fundamental frequency for note C3.
Fundamental frequency for note C3#.
Fundamental frequency for note D3.
Fundamental frequency for note D3#.
Fundamental frequency for note E3.
Fundamental frequency for note F3.
Fundamental frequency for note F3#.
Fundamental frequency for note G3.
Fundamental frequency for note G3#.
Fundamental frequency for note A3.
Fundamental frequency for note A3#.
Fundamental frequency for note B3.
Fundamental frequency for note C4 - Middle C.
Fundamental frequency for note C4#.
Fundamental frequency for note D4.
Fundamental frequency for note D4#.
Fundamental frequency for note E4.
Fundamental frequency for note F4.
Fundamental frequency for note F4#.
Fundamental frequency for note G4.
Fundamental frequency for note G4#.
Fundamental frequency for note A4.
Fundamental frequency for note A4#.
Fundamental frequency for note B4.
Fundamental frequency for note C5.
Fundamental frequency for note C5#.
Fundamental frequency for note D5.
Fundamental frequency for note D5#.
Fundamental frequency for note E5.
Fundamental frequency for note F5.
Fundamental frequency for note F5#.
Fundamental frequency for note G5.
Fundamental frequency for note G5#.
Fundamental frequency for note A5.
Fundamental frequency for note A5#.
Fundamental frequency for note B5.
Fundamental frequency for note C6.
Fundamental frequency for note C6#.
Fundamental frequency for note D6.
Fundamental frequency for note D6#.
Fundamental frequency for note E6.
Fundamental frequency for note F6.
Fundamental frequency for note F6#.
Fundamental frequency for note G6.
Fundamental frequency for note G6#.
Fundamental frequency for note A6.
Fundamental frequency for note A6#.
Fundamental frequency for note B6.
Fundamental frequency for note C7.
Fundamental frequency for note C7#.
Fundamental frequency for note D7.
Fundamental frequency for note D7#.
Fundamental frequency for note E7.
Fundamental frequency for note F7.
Fundamental frequency for note F7#.
Fundamental frequency for note G7.
Fundamental frequency for note G7#.
Fundamental frequency for note A7.
Fundamental frequency for note A7#.
Fundamental frequency for note B7.
Fundamental frequency for note C8.
Fundamental frequency for note C8#.
Fundamental frequency for note D8.
Fundamental frequency for note D8#.
Note ID for "Middle C"
Creates a new note of the specified frequency and length.
Default note will be rest (zero frequency), quarter note.
It is expected that objects will be constructed using object intializers.
// Create a 3/8th length, middle C note
Note note1 = new Note { Frequency = Note.C4, NamedValue = NoteValue.Quarter, Dots = 1 };
// Create a 1/8th length, E above middle C note
Note note2 = new Note { ID = "E4", NamedValueBritish = NoteValueBritish.Quaver };
// Create a whole length, F# above middle C note, "p" soft dynamic
Note note3 = new Note { Frequency = Note.F4S, Value = 1.0, NamedDynamic = Dynamic.Piano };
Calculates the actual time duration, in seconds, for the specified tempo that
the note value will last. For example, if tempo is M.M. 120 quarter-notes per
minte, then each quarter-note would last a half-second.
Tempo used to calculate note value time.
Calculated note value time.
Calculated value is cached and available from property.
Returns a string representation for the note.
A value representation for the note.
Returns True if the frequency and value of this note equals the frequency and value of the specified other note.
The other to compare against.
A indicating the result.
Returns True if the frequency and value of this note equals the frequency and value of the specified other note.
The other to compare against.
A indicating the result.
Notes are compared by frequency, then by value (i.e., duration).
A that is compared against.
An that indicates: this object is greater than if 1, equal to if 0, or less than if -1.
Notes are compared by frequency, then by value (i.e., duration).
An that is compared against.
An that indicates: this object is greater than if 1, equal to if 0, or less than if -1.
Serves as a hash function for the current .
A hash code for the current .
Compares two frequencies and values for equality.
A left hand operand.
A right hand operand.
A boolean indicating the result of the comparison.
Compares two frequencies and values for inequality.
A left hand operand.
A right hand operand.
A boolean indicating the result of the comparison.
Returns true if left timestamp is greater than right .
A left hand operand.
A right hand operand.
A boolean indicating the result of the comparison.
Returns true if left timestamp is greater than or equal to right .
A left hand operand.
A right hand operand.
A boolean indicating the result of the comparison.
Returns true if left timestamp is less than right .
A left hand operand.
A right hand operand.
A boolean indicating the result of the comparison.
Returns true if left timestamp is less than or equal to right .
A left hand operand.
A right hand operand.
A boolean indicating the result of the comparison.
Returns closest note value index (for or )
given the relative duration of a note.
Relative duration of the note.
Closest note value enumeration index given the relative duration of a note.
Gets the specified note frequency.
ID of the note to retrieve - expected format is "Note + Octave + S?" (e.g., A2 or C5S)
The specified note.
noteID is null.
Invalid note ID format - expected "Note + Octave + S?" (e.g., A2 or C5S).
Gets the specified note frequency.
Note (A - G) to retrieve.
Octave of the the note to retrieve (0 - 8).
Indicates to get the "sharp" version of the note.
The specified note.
Notes must be A - G, octaves must be 0 - 8, first note is C0, last note is D8S.
Sharps are not defined for notes 'B' and 'E'.
Gets the next note ID in sequence after the specified note ID.
ID of the current note - expected format is "Note + Octave + S?" (e.g., A2 or C5S)
Set to True to include sharp notes in the sequence.
The next note ID that is after the specified note ID.
noteID is null.
Invalid note ID format - expected "Note + Octave + S?" (e.g., A2 or C5S).
Gets the previous note ID in sequence before the specified note ID.
ID of the current note - expected format is "Note + Octave + S?" (e.g., A2 or C5S)
Set to True to include sharp notes in the sequence.
The previous note ID that is before the specified note ID.
noteID is null.
Invalid note ID format - expected "Note + Octave + S?" (e.g., A2 or C5S).
Gets or sets frequency of this note.
Gets or sets note ID of the note.
noteID is null.
Invalid note ID format - expected "Note + Octave + S?" (e.g., A2 or C5S).
Get or sets the relative note value representing the length of the note.
Gets the cached note value time, in seconds, calculated from a call to .
Get or sets the note value, expressed in American form, representing the length of the note.
Get or sets the note value, expressed in British form, representing the length of the note.
Gets or sets the total dotted note length extensions that apply to this note.
This is only used in conjunction with the named note values.
Gets or sets the individual tibre function used to synthesize the sounds
for this note (i.e., the instrument). If this timbre function is not defined,
the timbre of the song will be used for the note.
Set this value to null to use current timbre function of the song.
Gets or sets the individual damping function used to lower the sound volume
for this note over time. If this damping function is not defined, the
damping algorithm of the song will be used for the note.
Gets or sets the named dynamic (i.e., volume) for this note. If the dynamic
is undefined, the dynamic of the song will be used.
Set this value to undefined to use the current dynamic of the song.
Gets or sets the dynamic (i.e., volume) expressed as percentage in
the range of 0 to 1 for this note. If the dynamic is set to -1, the
dynamic of the song will be used.
Set this value to -1 to use the current dynamic of the song.
Value must be expressed as a fractional percentage between zero and one.
Gets or sets start time index for this note.
This is typically assigned and used by host
Gets or sets end time index for this note.
This is typically assigned and used by host
Gets or sets the sample period for this note.
This is typically assigned and used by host
American note value (♪) representing the relative duration of a note.
Note duration formula accessible via extension function "Duration()" for given note value.
Quadruple whole note (i.e., 4 times the length of a whole note).
Double whole note (i.e., 2 times the length of a whole note).
Whole note.
Half note (i.e., 1/2 the length of a whole note).
Quarter note (i.e., 1/4 the length of a whole note).
Eighth note (i.e., 1/8 the length of a whole note).
Sixteenth note (i.e., 1/16 the length of a whole note).
ThirtySecond note (i.e., 1/32 the length of a whole note).
SixtyFourth note (i.e., 1/64 the length of a whole note).
HundredTwentyEighth note (i.e., 1/128 the length of a whole note).
TwoHundredFiftySixth note (i.e., 1/256 the length of a whole note).
FiveHundredTwelfth note (i.e., 1/512 the length of a whole note).
ThousandTwentyFourth note (i.e., 1/1024 the length of a whole note).
British note value (♪) representing the relative duration of a note.
Note duration formula accessible via extension function "Duration()" for given note value.
Quadruple whole note (i.e., 4 times the length of a whole note).
Double whole note (i.e., 2 times the length of a whole note).
Whole note.
Half note (i.e., 1/2 the length of a whole note).
Quarter note (i.e., 1/4 the length of a whole note).
Eighth note (i.e., 1/8 the length of a whole note).
Sixteenth note (i.e., 1/16 the length of a whole note).
ThirtySecond note (i.e., 1/32 the length of a whole note).
SixtyFourth note (i.e., 1/64 the length of a whole note).
HundredTwentyEighth note (i.e., 1/128 the length of a whole note).
TwoHundredFiftySixth note (i.e., 1/256 the length of a whole note).
FiveHundredTwelfth note (i.e., 1/512 the length of a whole note).
ThousandTwentyFourth note (i.e., 1/1024 the length of a whole note).
Defines extension functions related to note value enumerations.
Returns source note value duration. For example, 0.25 will be returned for
a quater note, 1.0 will be returned for a whole note, etc.
Source note value.
Duration of note value.
Returns source note value duration. For example, 0.25 will be returned for
a crotchet note, 1.0 will be returned for a semibreve note, etc.
Source note value.
Duration of note value.
Returns source note value duration. For example, 0.25 will be returned for
a quater note, 1.0 will be returned for a whole note, etc.
Source note value.
Total dotted note length extensions to apply.
Duration of note value.
Returns source note value duration. For example, 0.25 will be returned for
a crotchet note, 1.0 will be returned for a semibreve note, etc.
Source note value.
Total dotted note length extensions to apply.
Duration of note value.
Returns source note value duration in terms of given reference note value.
For example, if measure size is 3/4 then reference is quarter notes and returned
value will be equivalent number of quarter notes for given source note.
Source note value.
Reference note value.
Duration of note value in terms of specified reference note value.
Returns source note value duration in terms of given reference note value.
For example, if measure size is 3/4 then reference is quarter notes and returned
value will be equivalent number of quarter notes for given source note.
Source note value.
Reference note value.
Duration of note value in terms of specified reference note value.
Returns source note value duration in terms of given reference note value.
For example, if measure size is 3/4 then reference is quarter notes and returned
value will be equivalent number of quarter notes for given source note.
Source note value.
Reference note value.
Total dotted note length extensions to apply.
Duration of note value in terms of specified reference note value.
Returns source note value duration in terms of given reference note value.
For example, if measure size is 3/4 then reference is quarter notes and returned
value will be equivalent number of quarter notes for given source note.
Source note value.
Reference note value.
Total dotted note length extensions to apply.
Duration of note value in terms of specified reference note value.
Defines a repeatable series of notes that can be added to a song over and over,
for example, the phrase of music defining the chorus.
Constructs a new .
Add another predefined phrase of notes to this phrase.
Phrase to add.
Add a series of notes to the phrase.
Notes to add.
Series of notes that define the phrase.
Allows creation of a synthesized musical score storing the resultant song in an
in-memory wave file for play back or saving music to disk.
This example generates a multi-instrument chord:
using System;
using GSF.Media;
using GSF.Media.Music;
static class Program
{
static void Main()
{
Song song = new Song { Damping = Damping.Linear };
Console.WriteLine("Generating multi-instrument chord...");
song.AddNotes
(
new Note { Frequency = Note.C4, Value = 4, Timbre = Timbre.EvenHarmonicSeries },
new Note { Frequency = Note.C4, Value = 4, Timbre = Timbre.Clarinet },
new Note { Frequency = Note.C4, Value = 4, Timbre = Timbre.Organ },
new Note { Frequency = Note.E4, Value = 4, Timbre = Timbre.EvenHarmonicSeries },
new Note { Frequency = Note.E4, Value = 4, Timbre = Timbre.Clarinet },
new Note { Frequency = Note.E4, Value = 4, Timbre = Timbre.Organ },
new Note { Frequency = Note.G4, Value = 4, Timbre = Timbre.EvenHarmonicSeries },
new Note { Frequency = Note.G4, Value = 4, Timbre = Timbre.SimulatedClarinet },
new Note { Frequency = Note.G4, Value = 4, Timbre = Timbre.SimulatedOrgan }
);
song.Finish();
Console.WriteLine("Saving chord to disk...");
song.Save("MajorTriad.wav");
Console.WriteLine("Playing chord...");
song.Play();
Console.ReadKey();
}
}
This example generates a familiar tune, plays the song and saves it to disk:
// Add reference to System.Speech
using System;
using System.IO;
using GSF.Media;
using GSF.Media.Music;
using System.Speech;
using System.Speech.Synthesis;
using System.Speech.AudioFormat;
static class Program
{
static void Main()
{
Console.WriteLine("Synthesizing speech...");
WaveFile speech = CreateSynthesizedVoiceOver();
Console.WriteLine("Synthesizing song at tempo for use with speech...");
// Define all the notes of jingle bells as a single phrase of music
Phrase score = CreateJingleBellsScore();
// Create one song at a slower tempo to help with speech synchronization
Song speechTempSong = new Song { Tempo = new Tempo(160, NoteValue.Quarter) };
// Make sure audio specifications for song and speech match
speechTempSong.SampleRate = speech.SampleRate;
speechTempSong.BitsPerSample = speech.BitsPerSample;
speechTempSong.Channels = speech.Channels;
// Add all the notes to the song
speechTempSong.AddPhrase(score);
speechTempSong.Finish();
Console.WriteLine("Synthesizing song by itself at normal tempo...");
// Create one song at a slower tempo to help with speech synchronization
Song normalTempoSong = new Song();
// Add all the notes to the song
normalTempoSong.AddPhrase(score);
normalTempoSong.Finish();
Console.WriteLine("Saving normal tempo song to disk as \"JingleBells.wav\"...");
normalTempoSong.Save("JingleBells.wav");
Console.WriteLine("Combining speech with song...");
WaveFile combined = WaveFile.Combine(speech, speechTempSong);
Console.WriteLine("Saving combined work to disk as \"SingingComputer.wav\"...");
combined.Save("SingingComputer.wav");
Console.WriteLine("Playing combined work...");
combined.Play();
Console.ReadKey();
}
private static WaveFile CreateSynthesizedVoiceOver()
{
SpeechSynthesizer synthesizer = new SpeechSynthesizer();
MemoryStream speechStream = new MemoryStream();
PromptBuilder songText = new PromptBuilder();
synthesizer.SelectVoice("Microsoft Sam");
synthesizer.Rate = 5; // Range = -10 to +10
synthesizer.SetOutputToWaveStream(speechStream);
songText.AppendText("Jin - gull bells!", PromptEmphasis.Strong);
songText.AppendBreak(new TimeSpan(3000000));
songText.AppendText("Jin - gull bells!", PromptEmphasis.Strong);
songText.AppendBreak(new TimeSpan(3000000));
songText.AppendText("Jin - gull - all, theuh - way!", PromptEmphasis.Strong);
songText.AppendBreak(new TimeSpan(12000000));
songText.AppendText("Oh - what - fun!", PromptEmphasis.Strong);
songText.AppendBreak(new TimeSpan(1000000));
songText.AppendText("It - is!", PromptEmphasis.Strong);
songText.AppendBreak(new TimeSpan(500000));
songText.AppendText("To - ride!", PromptEmphasis.Strong);
songText.AppendBreak(new TimeSpan(500000));
songText.AppendText("a - one - horse!", PromptEmphasis.Strong);
songText.AppendBreak(new TimeSpan(500000));
songText.AppendText("Open!", PromptEmphasis.Strong);
songText.AppendBreak(new TimeSpan(500000));
songText.AppendText("Sleigh!", PromptEmphasis.Strong);
songText.AppendBreak(new TimeSpan(1000000));
songText.AppendText("A!", PromptEmphasis.Strong);
songText.AppendBreak(new TimeSpan(2500000));
songText.AppendText("Jin - gull bells!", PromptEmphasis.Strong);
songText.AppendBreak(new TimeSpan(3000000));
songText.AppendText("Jin - gull bells!", PromptEmphasis.Strong);
songText.AppendBreak(new TimeSpan(3000000));
songText.AppendText("Jin - gull - all, theuh - way!", PromptEmphasis.Strong);
songText.AppendBreak(new TimeSpan(12000000));
songText.AppendText("Oh - what - fun!", PromptEmphasis.Strong);
songText.AppendBreak(new TimeSpan(1000000));
songText.AppendText("It - is!", PromptEmphasis.Strong);
songText.AppendBreak(new TimeSpan(500000));
songText.AppendText("To - ride!", PromptEmphasis.Strong);
songText.AppendBreak(new TimeSpan(500000));
songText.AppendText("a - one - horse!", PromptEmphasis.Strong);
songText.AppendBreak(new TimeSpan(500000));
songText.AppendText("Open!", PromptEmphasis.Strong);
songText.AppendBreak(new TimeSpan(500000));
songText.AppendText("Sleigh.", PromptEmphasis.Reduced);
synthesizer.Speak(songText);
speechStream.Position = 0;
return WaveFile.Load(speechStream);
}
private static Phrase CreateJingleBellsScore()
{
Phrase score = new Phrase();
Phrase passage = new Phrase();
// Define the repeating phrase of the song
passage.AddNotes
(
new Note { Frequency = Note.B3, NamedValue = NoteValue.Quarter },
new Note { Frequency = Note.C3, NamedValue = NoteValue.Whole }
);
passage.AddNotes(new Note { Frequency = Note.B3, NamedValue = NoteValue.Quarter });
passage.AddNotes(new Note { Frequency = Note.B3, NamedValue = NoteValue.Half });
passage.AddNotes
(
new Note { Frequency = Note.B3, NamedValue = NoteValue.Quarter },
new Note { Frequency = Note.G3, NamedValue = NoteValue.Whole }
);
passage.AddNotes(new Note { Frequency = Note.B3, NamedValue = NoteValue.Quarter });
passage.AddNotes(new Note { Frequency = Note.B3, NamedValue = NoteValue.Half });
passage.AddNotes
(
new Note { Frequency = Note.B3, NamedValue = NoteValue.Quarter },
new Note { Frequency = Note.C3, NamedValue = NoteValue.Whole }
);
passage.AddNotes(new Note { Frequency = Note.D4, NamedValue = NoteValue.Quarter });
passage.AddNotes(new Note { Frequency = Note.G3, NamedValue = NoteValue.Quarter });
passage.AddNotes(new Note { Frequency = Note.A3, NamedValue = NoteValue.Quarter });
passage.AddNotes
(
new Note { Frequency = Note.B3, NamedValue = NoteValue.Whole },
new Note { Frequency = Note.G3, NamedValue = NoteValue.Whole }
);
passage.AddNotes
(
new Note { Frequency = Note.C4, NamedValue = NoteValue.Quarter },
new Note { Frequency = Note.D3, NamedValue = NoteValue.Whole }
);
passage.AddNotes(new Note { Frequency = Note.C4, NamedValue = NoteValue.Quarter });
passage.AddNotes(new Note { Frequency = Note.C4, NamedValue = NoteValue.Quarter });
passage.AddNotes(new Note { Frequency = Note.C4, NamedValue = NoteValue.Quarter });
passage.AddNotes
(
new Note { Frequency = Note.C4, NamedValue = NoteValue.Quarter },
new Note { Frequency = Note.G3, NamedValue = NoteValue.Whole }
);
passage.AddNotes(new Note { Frequency = Note.B3, NamedValue = NoteValue.Quarter });
passage.AddNotes(new Note { Frequency = Note.B3, NamedValue = NoteValue.Quarter });
passage.AddNotes(new Note { Frequency = Note.B3, NamedValue = NoteValue.Quarter });
score.AddPhrase(passage);
score.AddNotes
(
new Note { Frequency = Note.B3, NamedValue = NoteValue.Quarter },
new Note { Frequency = Note.F3S, NamedValue = NoteValue.Whole }
);
score.AddNotes(new Note { Frequency = Note.A3, NamedValue = NoteValue.Quarter });
score.AddNotes(new Note { Frequency = Note.A3, NamedValue = NoteValue.Quarter });
score.AddNotes(new Note { Frequency = Note.B3, NamedValue = NoteValue.Quarter });
score.AddNotes
(
new Note { Frequency = Note.A3, NamedValue = NoteValue.Half },
new Note { Frequency = Note.G3, NamedValue = NoteValue.Whole }
);
score.AddNotes(new Note { Frequency = Note.D4, NamedValue = NoteValue.Half });
score.AddPhrase(passage);
score.AddNotes
(
new Note { Frequency = Note.D4, NamedValue = NoteValue.Quarter },
new Note { Frequency = Note.G3, NamedValue = NoteValue.Whole },
new Note { Frequency = Note.F3, NamedValue = NoteValue.Whole }
);
score.AddNotes(new Note { Frequency = Note.D4, NamedValue = NoteValue.Quarter });
score.AddNotes(new Note { Frequency = Note.C4, NamedValue = NoteValue.Quarter });
score.AddNotes(new Note { Frequency = Note.A3, NamedValue = NoteValue.Quarter });
score.AddNotes
(
new Note { Frequency = Note.G3, NamedValue = NoteValue.Whole },
new Note { Frequency = Note.E3, NamedValue = NoteValue.Whole }
);
return score;
}
}
Represents a waveform audio format file (WAV).
Creates a new empty in-memory wave file using standard CD quality settings.
Creates a new empty in-memory wave file in Pulse Code Modulation (PCM) audio format.
Desired sample rate.
Desired bits-per-sample.
Desired data channels.
Creates a new empty in-memory wave file in specified audio format.
Desired sample rate.
Desired bits-per-sample.
Desired data channels.
Desired audio format.
Consumer will need to apply appropriate data compression for non-PCM data formats.
Creates a new empty in-memory wave file in Pulse Code Modulation (PCM) audio format.
Desired sample rate (e.g., 44100).
Desired bits-per-sample (e.g., 16).
Desired data channels (e.g., 2 for stereo).
Creates a new empty in-memory wave file in specified audio format.
Desired sample rate (e.g., 44100).
Desired bits-per-sample (e.g., 16).
Desired data channels (e.g., 2 for stereo).
Desired audio format (e.g., 0x1 for Pulse Code Modulation).
Consumer will need to apply appropriate data compression for non-PCM data formats.
Creates a new empty in-memory wave file using existing constituent chunks.
A header object.
A format object.
A data object
Optional object.
Add the sample to the wave file.
Sample to add to the wave file.
Sample is applied to all channels and cast to the appropriate size. Sample should be scaled
by for integer based wave file formats to make sure sample will
fit into defined by wave file.
If you have samples to apply to individual channels (e.g., for a stereo format), use the
method instead.
Adds a series of samples, one per channel, to the wave file.
Samples to add to the wave file.
You need to pass in one sample for each defined channel (e.g., if wave is configured for stereo
you will need to pass in two parameters).
Each sample will be cast to the appropriate size. Samples should be scaled by
for integer based wave file formats to make sure samples will fit into defined
by wave file.
Adds a block of samples in native format to the wave file (e.g., if = 16,
parameters need to be Int16 values). Note that parameter type is
implicitly castable to common native types, including floating points.
Samples to add to the wave file.
You need to pass in one sample for each defined channel (e.g., if wave is configured for stereo
you will need to pass in two parameters).
You should only add values that match the wave file's (e.g., if wave file is
configured for 16-bits only pass in Int16 values, casting if necessary).
Plays the wave file using .
Saves wave file to the specified file name.
Desired destination file name for wave file.
Saves wave file to the specified stream.
Destination stream for binary wave file data.
Reverses the data samples in the wave file.
This is just used to reverse the sound in the file for effect.
Creates a deeply cloned copy of the .
A deeply cloned copy of the .
Determines sample data type code based on defined
and .
Sample type code based on defined and
.
Casts sample value to its equivalent native type based on defined
and .
Sample value.
Sample value cast to its equivalent native type based on defined
and .
Creates a new in-memory wave loaded from an existing wave file.
File name of WAV file to load.
Determines if wave data should be loaded into memory.
In-memory representation of wave file.
Creates a new in-memory wave loaded from an existing wave audio stream.
Stream of WAV formatted audio data to load.
Determines if wave data should be loaded into memory.
In-memory representation of wave file.
Combines wave files together, all starting at the same time, into a single file.
This has the effect of playing two sound tracks simultaneously.
Wave files to combine
Combined wave files.
This overload "equalizes" the volume of each source wave file. To specify a desired volume for
each combined wave file use the overload that takes
a series of volumes as a parameter.
Resulting sounds will overlap; no truncation is performed. Final wave file length will equal length of
longest source file.
Combining sounds files with non-PCM based audio formats will have unexpected results.
Combines wave files together, all starting at the same time, into a single file.
This has the effect of playing two sound tracks simultaneously.
Wave files to combine
Volume for each wave file (0.0 to 1.0)
Combined wave files.
Cumulatively, volumes cannot exceed 1.0 - these volumes represent a fractional percentage
of volume to be applied to each wave file.
Resulting sounds will overlap; no truncation is performed. Final wave file length will equal length of
longest source file.
Combining sounds files with non-PCM based audio formats will have unexpected results.
Appends wave files together, one after another, into a single file.
Wave files to append
Combined wave files.
Each resulting wave file is appending behind the next.
Performs a deep clone of all the channel samples in a sample block.
Sample block to clone.
A deep clone of all the channel samples in a sample block.
Gets or sets audio format used by the .
PCM = 1 (i.e., linear quantization), values other than 1 typically indicate some form of compression.
See enumeration for more details.
Gets or sets number of audio channels in the .
This property defines the number of channels (e.g., mono = 1, stereo = 2, etc.) defined
in each sample block. See enumeration for more details.
Gets or sets the sample rate (i.e., the number of samples per second) defined in the .
This property defines the number of samples per second defined in each second of data in
the . See enumeration for more details.
Gets or sets the byte rate used for buffer estimation.
This property is not usually changed. It will be automatically calculated for new wave files.
This is typically just the arithmetic result of:
* * / 8.
However, this value can be changed as needed to accommodate better buffer estimations during
data read cycle.
Gets or sets the block size of a complete sample of data (i.e., samples for all channels of data at
one instant in time).
This property is not usually changed. It will be automatically calculated for new wave files.
This is typically just the arithmetic result of:
* / 8.
However, this value can be changed as needed to accommodate even block-alignment of non-standard
values.
Gets or sets number of bits-per-sample in the .
This property defines the number of bits-per-sample (e.g., 8, 16, 24, 32, etc.) used
by each sample in a block of samples - effectively the data sample size. See
enumeration for more details.
Returns the amplitude scalar for the given bits per sample of the WaveFile (i.e., maximum value
for given ).
This defines a scaling factor (essentially a maximum value) used for integer based wave file
formats. Floating point wave file formats do not need such scaling.
Gets list of info strings available in this if any were available during load; otherwise an empty dictionary.
The current implementation only allows reading of loaded metadata tags, not updating them.
Gets calculated audio length.
Gets the size of the buffer, if defined.
Gets or sets any extra parameters defined in the format header of the .
See the class for an example of usage of this property.
Accesses each individual block of sample data indexed by time.
Gets or sets the of this .
Gets or sets the of this .
Gets or sets the of this .
Gets the of this .
Creates a new song with a 3/4 measure size, a tempo of 240 quarter-notes per minute,
mezzo-forte prevailing dynamic level, using a basic note timbre and standard CD-quality
settings for the underlying sound file.
Creates a new song with a 3/4 measure size, a tempo of 240 quarter-notes per minute,
mezzo-forte prevailing dynamic level, using a basic note timbre and the specified
audio format settings.
Desired sample rate
Desired bits-per-sample
Desired data channels
Add a predefined phrase of notes to the song.
Phrase to add.
Add a series of notes to the song.
Notes to add.
Called when there are no more notes to add.
This flushes the remaining queued notes into the song allowing them to run their remaining time.
Add a rest for the given length for the current beat.
Duration of wait specified as a note value.
Add a rest for the given length for the current beat.
Duration of wait specified as a note value.
Add a rest for the given length for the current beat.
Duration of wait specified as a note value.
Add a rest for the given length for the current beat.
Duration of wait specified as a note value.
Total dotted note length extensions to apply.
Add a rest for the given length for the current beat.
Duration of wait specified as a note value.
Total dotted note length extensions to apply.
Starts crescendo dynamic over the range of the specified number of beats.
Total number of beats overwhich to gradually increase volume.
Desired volume when crescendo is complete.
Current is the starting dynamic which should be less than .
Starts diminuendo dynamic over the range of the specified number of beats.
Total number of beats overwhich to gradually decrease volume.
Desired volume when diminuendo is complete.
Current is the starting dynamic which should be greater than .
Gets current measure size or defines a new measure size for the song.
Gets current tempo or defines a new tempo for the song.
Returns the time for a single beat.
Gets or sets the default tibre function used to synthesize the sounds
of the added notes (i.e., the instrument). This timbre function will be
used if no other function is specified when adding notes.
Gets or sets the default damping function used to lower the sound volume
of the added notes over time. This damping function will be used if no
other function is specified when adding notes.
Gets or sets the prevailing named dynamic (i.e., volume) for the song. Individual notes
can choose to override this dynamic.
Gets or sets the prevailing dynamic (i.e., volume) expressed as percentage in the range
of 0 to 1 for the song. Individual notes can choose to override this dynamic.
Value must be expressed as a fractional percentage between zero and one.
Injects specified rest time, in seconds, between notes.
Defines the tempo of song as the total number of note values in one minute.
This defined tempo of the music assigns absolute durations to all the
note values within a score.
Contructs a new object.
Total note values for .
Note value used for .
Contructs a new object.
Total note values for .
Named note value used for .
Contructs a new object.
A indicating the total note values.
Named note value used for .
Calculates the actual time duration, in seconds, for the given tempo that the specified
source note value will last. For example, if tempo is M.M. 120 quarter-notes per minute,
then each quarter-note would last a half-second.
Relative value of note.
Actual duration of note value in seconds.
Calculates the actual time duration, in seconds, for the given tempo that the specified
source note value will last. For example, if tempo is M.M. 120 quarter-notes per minute,
then each quarter-note would last a half-second.
Source note value.
Total dotted note length extensions to apply.
Actual duration of note value in seconds.
Calculates the actual time duration, in seconds, for the given tempo that the specified
source note value will last. For example, if tempo is M.M. 120 crotchets per minute,
then each crotchet would last a half-second.
Source note value.
Total dotted note length extensions to apply.
Actual duration of note value in seconds.
Total number of reference note values that occur in one minute - thus defining
the tempo for a score.
Returns relative value for reference note value. For example, if tempo is
M.M. 120 quarter-notes per minute, then time is referenced in quarter-notes
and this function would return 0.25.
Total time, in seconds, for reference note value. For example, if tempo is
M.M. 120 quarter-notes per minute, then time is referenced in quarter-notes
and this function would return 0.5 seconds.
Get or sets the note value, expressed in American form, representing the length of the note.
Get or sets the note value, expressed in British form, representing the length of the note.
Provides a function signature for methods that produce an amplitude representing the
acoustic pressure of a represented musical timbre for the given time.
Fundamental frequency of the desired note in Hz.
Sample index (represents time anywhere from zero to full length of song).
If useful, total period for note in whole samples per second (i.e., seconds of time * ) over which to compute timbre.
Number of samples per second.
The amplitude of the represented musical timbre (a value between zero and one) at the given time.
Defines a few timbre functions.
Computes the angular frequency for the given time.
Frequency in Hz.
Sample index (represents time anywhere from zero to full length of song).
Number of samples per second.
The computed angular frequency in radians per second at given time.
Generates a pure tone for the given frequency and time.
Fundamental frequency of the desired note in Hz.
Sample index (represents time anywhere from zero to full length of song).
If useful, total period for note in whole samples per second (i.e., seconds of time * ) over which to compute timbre.
Number of samples per second.
The amplitude for a pure tone at the given time.
This method computes an amplitude representing the acoustic pressure of a
pure tone of the given frequency for the given time.
Generates a basic note for the given frequency and time.
Fundamental frequency of the desired note in Hz.
Sample index (represents time anywhere from zero to full length of song).
If useful, total period for note in whole samples per second (i.e., seconds of time * ) over which to compute timbre.
Number of samples per second.
The amplitude for a basic note at the given time.
This method computes an amplitude representing the acoustic pressure of a
basic note of the given frequency for the given time.
This timbre algorithm combines the simulated piano and the odd harmonic series
algoriths to produce a pleasant sounding note.
Generates a simulated piano note for the given frequency and time.
Fundamental frequency of the desired note in Hz.
Sample index (represents time anywhere from zero to full length of song).
If useful, total period for note in whole samples per second (i.e., seconds of time * ) over which to compute timbre.
Number of samples per second.
The amplitude for a simulated piano note at the given time.
This method computes an amplitude representing the acoustic pressure of a
simulated piano note of the given frequency for the given time.
Generates a simulated flute note for the given frequency and time.
Fundamental frequency of the desired note in Hz.
Sample index (represents time anywhere from zero to full length of song).
If useful, total period for note in whole samples per second (i.e., seconds of time * ) over which to compute timbre.
Number of samples per second.
The amplitude for a simulated flute note at the given time.
This method computes an amplitude representing the acoustic pressure of a
simulated flute note of the given frequency for the given time.
Generates a simulated acoustic guitar note for the given frequency and time.
Fundamental frequency of the desired note in Hz.
Sample index (represents time anywhere from zero to full length of song).
If useful, total period for note in whole samples per second (i.e., seconds of time * ) over which to compute timbre.
Number of samples per second.
The amplitude for a acoustic simulated guitar note at the given time.
This method computes an amplitude representing the acoustic pressure of a
simulated acoustic guitar note of the given frequency for the given time.
Generates a simulated bass guitar note for the given frequency and time.
Fundamental frequency of the desired note in Hz.
Sample index (represents time anywhere from zero to full length of song).
If useful, total period for note in whole samples per second (i.e., seconds of time * ) over which to compute timbre.
Number of samples per second.
The amplitude for a simulated bass guitar note at the given time.
This method computes an amplitude representing the acoustic pressure of a
simulated bass guitar note of the given frequency for the given time.
Generates a simulated electric guitar note for the given frequency and time.
Fundamental frequency of the desired note in Hz.
Sample index (represents time anywhere from zero to full length of song).
If useful, total period for note in whole samples per second (i.e., seconds of time * ) over which to compute timbre.
Number of samples per second.
The amplitude for a simulated electric guitar note at the given time.
This method computes an amplitude representing the acoustic pressure of a
simulated electric guitar note of the given frequency for the given time.
Generates a simulated bell note for the given frequency and time.
Fundamental frequency of the desired note in Hz.
Sample index (represents time anywhere from zero to full length of song).
If useful, total period for note in whole samples per second (i.e., seconds of time * ) over which to compute timbre.
Number of samples per second.
The amplitude for a simulated bell note at the given time.
This method computes an amplitude representing the acoustic pressure of a
simulated bell note of the given frequency for the given time.
Generates a simulated big bell note for the given frequency and time.
Fundamental frequency of the desired note in Hz.
Sample index (represents time anywhere from zero to full length of song).
If useful, total period for note in whole samples per second (i.e., seconds of time * ) over which to compute timbre.
Number of samples per second.
The amplitude for a simulated big bell note at the given time.
This method computes an amplitude representing the acoustic pressure of a
simulated big bell note of the given frequency for the given time.
Generates a simulated chime bell note for the given frequency and time.
Fundamental frequency of the desired note in Hz.
Sample index (represents time anywhere from zero to full length of song).
If useful, total period for note in whole samples per second (i.e., seconds of time * ) over which to compute timbre.
Number of samples per second.
The amplitude for a simulated chime bell note at the given time.
This method computes an amplitude representing the acoustic pressure of a
simulated chime bell note of the given frequency for the given time.
Generates a simulated xylophone note for the given frequency and time.
Fundamental frequency of the desired note in Hz.
Sample index (represents time anywhere from zero to full length of song).
If useful, total period for note in whole samples per second (i.e., seconds of time * ) over which to compute timbre.
Number of samples per second.
The amplitude for a simulated xylophone note at the given time.
This method computes an amplitude representing the acoustic pressure of a
simulated xylophone note of the given frequency for the given time.
Generates a simulated clarinet note for the given frequency and time.
Fundamental frequency of the desired note in Hz.
Sample index (represents time anywhere from zero to full length of song).
If useful, total period for note in whole samples per second (i.e., seconds of time * ) over which to compute timbre.
Number of samples per second.
The amplitude for a simulated clarinet note at the given time.
This method computes an amplitude representing the acoustic pressure of a
simulated clarinet note of the given frequency for the given time.
Generates a simulated organ note for the given frequency and time.
Fundamental frequency of the desired note in Hz.
Sample index (represents time anywhere from zero to full length of song).
If useful, total period for note in whole samples per second (i.e., seconds of time * ) over which to compute timbre.
Number of samples per second.
The amplitude for a simulated clarinet note at the given time.
This method computes an amplitude representing the acoustic pressure of a second-order
harmonic series approaching a square wave (i.e., Sin(f) + Sin(3f)/3) of the given
frequency for the given time to simulate an organ sound.
Generates an odd harmonic series for the given frequency and time.
Fundamental frequency of the desired note in Hz.
Sample index (represents time anywhere from zero to full length of song).
If useful, total period for note in whole samples per second (i.e., seconds of time * ) over which to compute timbre.
Number of samples per second.
The amplitude for a simulated clarinet note at the given time.
This method computes an amplitude representing the acoustic pressure of an
odd harmonic series of the given frequency for the given time.
Algorithm: Sin(f) + Sin(3f)/3 + Sin(5f)/5, etc.
Generates an even harmonic series for the given frequency and time.
Fundamental frequency of the desired note in Hz.
Sample index (represents time anywhere from zero to full length of song).
If useful, total period for note in whole samples per second (i.e., seconds of time * ) over which to compute timbre.
Number of samples per second.
The amplitude for a simulated clarinet note at the given time.
This method computes an amplitude representing the acoustic pressure of an
even harmonic series of the given frequency for the given time.
Algorithm: Sin(2f) + Sin(4f)/3 + Sin(6f)/5, etc.
Contains classes used to create and manipulate waveform audio format (WAV) files.
Represents the header chunk in a RIFF media format file.
Type ID of a RIFF header chunk.
The fixed byte length of a instance.
Constructs a new RIFF header chunk for the specified format.
RIFF header chunk header format.
Reads a new RIFF header from the specified stream.
Pre-parsed header.
Source stream to read data from.
Expected RIFF media format (e.g., "WAVE").
cannot be null.
must be extactly 4 characters in length.
Generates binary image of the object and copies it into the given buffer.
Buffer used to hold generated binary image of the source object.
0-based starting index in the to start writing.
The number of bytes written to the .
is null.
or is less than 0 -or-
and will exceed length.
Returns a cloned instance of this RIFF header chunk.
A cloned instance of this RIFF header chunk.
Gets or sets format for RIFF header chunk.
Gets length of binary representation of RIFF header chunk.
Dual Tone Multi-Frequency Class.
This example generates some familiar dual tone multi-frequency sounds
and plays them over the computer's speakers:
using System;
using GSF.Media;
using GSF.Media.Sound;
static class Program
{
static void Main()
{
WaveFile waveFile = new WaveFile(SampleRate.Hz8000, BitsPerSample.Bits16, DataChannels.Mono);
double volume = 0.25D; // Set volume of tones to 25% of maximum
DTMF tone;
// Get the dial tone dual-frequencies
tone = DTMF.DialTone;
// Change the duration of the dial-tone to 3 seconds
tone.Duration = 3.0D;
// Generate a dial tone
DTMF.Generate(waveFile, tone, volume);
// Generate a busy-signal tone, repeat four times
DTMF.Generate(waveFile, DTMF.BusySignal, volume, 4);
// Generate an off-the-hook tone, repeat eight times
DTMF.Generate(waveFile, DTMF.OffHook, volume, 8);
// Get the EBS Alert dual-frequencies
tone = DTMF.EmergencyBroadcastSystemAlert;
// The official duration of an EBS Alert is 22.5 seconds, but
// the noise is rather annoying - so we set it to 4 seconds
tone.Duration = 4.0D;
// Generate the EBS Alert noise
DTMF.Generate(waveFile, tone, volume);
// Play all the generated tones
waveFile.Play();
Console.ReadKey();
}
}
Low frequency of .
High frequency of .
Frequency duration, in seconds, of .
Constructs a new .
Constructs a new using specified parameters.
A low frequency value.
A high frequency value.
A duration value.
Computes a dual-tone multi-frequency sound for the given information and time.
Instance of the specifying the duration as well as the low and high frequencies of the dual-tone.
Sample index (represents time anywhere from zero to full length of tone).
Number of samples per second.
The amplitude for the dual-tone at the given time.
This method computes an amplitude representing the acoustic pressure of a
of the given frequency for the given time.
Generates the specified dual-tone multi-frequency storing it in the specified .
used to store generated dual-tone multi-frequencies.
Dual-tone multi-frequency to generate.
Volume of generated dual-tones as a percentage (0 to 1).
Generates the specified dual-tone multi-frequency times storing it in the specified .
used to store generated dual-tone multi-frequencies.
Dual-tone multi-frequency to generate.
Volume of generated dual-tones as a percentage (0 to 1).
Number of times to repeat the tone.
Generates a single instance of each of the specified dual-tone multi-frequencies storing them in the specified .
used to store generated dual-tone multi-frequencies.
Dual-tone multi-frequencies to generate.
Volume of generated dual-tones as a percentage (0 to 1).
Generates the specified dual-tone multi-frequencies times storing them in the specified .
used to store generated dual-tone multi-frequencies.
Dual-tone multi-frequencies to generate.
Volume of generated dual-tones as a percentage (0 to 1).
Number of times to repeat each tone.
Value must be expressed as a fractional percentage between zero and one.
only generated for with a sample rate of 8, 16, 24, 32 or 64 bits per sample.
Gets the instance representing a telephone dial tone.
Gets the instances representing a telephone off-the-hook signal.
Gets the instances representing a telephone busy signal.
Gets the instance representing the Emergency Broadcast System alert tone.
The official duration of an EBS Alert is 22.5 seconds.
Contains classes used to create dual tone multi-frequency sounds and standard touch tones.
Touch tone key enumeration.
Represents the number "0" on a touch tone key pad.
Represents the number "1" on a touch tone key pad.
Represents the number "2" on a touch tone key pad.
Represents the number "3" on a touch tone key pad.
Represents the number "4" on a touch tone key pad.
Represents the number "5" on a touch tone key pad.
Represents the number "6" on a touch tone key pad.
Represents the number "7" on a touch tone key pad.
Represents the number "8" on a touch tone key pad.
Represents the number "9" on a touch tone key pad.
Represents the "*" key on a touch tone key pad.
Represents the "#" key on a touch tone key pad.
Touch tone generator.
This example will "dial a phone number" over the computer's speakers:
using System;
using GSF.Media;
using GSF.Media.Sound;
static class Program
{
static void Main()
{
WaveFile waveFile = new WaveFile(SampleRate.Hz8000, BitsPerSample.Bits16, DataChannels.Mono);
double volume = 0.25D; // Set volume of TouchTone to 25% of maximum
string phoneNumber = "9, 1 (535) 217-1631";
// Generate touch tones for specified phone number
DTMF.Generate(waveFile, TouchTone.GetTouchTones(phoneNumber), volume);
Console.WriteLine("Dialing {0}...", phoneNumber);
waveFile.Play();
Console.ReadKey();
}
}
Valid touch tone keys.
Default duration, in seconds, of touch tones.
Default duration, in seconds, of pause between touch tones.
Constructs a new for specified touch tone key.
Touch tone to create.
Constructs a new for specified touch tone key character.
Character of touch tone to create.
is not a valid touch tone character.
Constructs a new for specified touch tone key number.
Number of touch tone to create (note that * = 10 and # = 11).
is not a valid touch tone number.
Get array of touch tones for given string.
String of touch tone characters to convert to touch tones.
Array of touch tones for given string.
Non-touch tone characters are ignored. Commas are interpreted as a one second pause.
Get array of touch tones for given string.
String of touch tone characters to convert to touch tones.
Duration of touch tone key press in seconds, typically fractional.
Time to wait between key presses in seconds, typically fractional.
Array of touch tones for given string.
Non-touch tone characters are ignored. Commas are interpreted as a one second pause.
Converts the character representation of a touch tone key into
an instance of the class. A return value
indicates whether the conversion succeeded.
A character containing a touch tone key to convert.
When this method returns, contains an instance of the
class equivalent to the touch tone key, if the conversion succeeded, or null
if the conversion failed. The conversion fails if the
parameter is not a valid touch tone.
true if s was converted successfully; otherwise, false.
Converts the character representation of a touch tone key into
an instance of the class.
A character containing a touch tone key to convert.
An instance of the class equivalent to the touch tone
chracter contained in .
is not a valid touch tone character.
Gets or sets touch tone key for this touch tone.
Represents the data chunk in a WAVE media format file.
Type ID of a WAVE data chunk.
Constructs a new WAVE data chunk for the specified format.
that describes this .
Reads a new WAVE format section from the specified stream.
Pre-parsed header.
Source stream to read data from.
Format of the data section to be parsed.
WAVE format or extra parameters section too small, wave file corrupted.
Generates a binary representation of this and copies it into the given buffer.
Buffer used to hold generated binary image of the source object.
0-based starting index in the to start writing.
The number of bytes written to the .
is null.
or is less than 0 -or-
and will exceed length.
Creates a deeply cloned copy of the .
A deeply cloned copy of the .
Gets or sets associated that defines the format of the data in this .
Gets list of little-endian formatted sample data blocks of this .
Gets the chunk size of this .
Gets length of the binary representation of this .
Represents wave data coming from a stream.
This class is meant to be used when loading the entirety
of a wave file into memory is not a viable option. With
it, samples can be read directly from the data stream in
the order that they appear.
Creates a new instance of the class.
The format of the wave stream.
The stream containing wave data.
Creates a new instance of the class.
The stream containing wave data.
Reads and returns the next sample from the stream.
The next sample from the stream. The sample is returned as
an array of s. Each
LittleBinaryValue represents a different channel.
A return value of null indicates the end of stream has been reached.
Closes the underlying stream.
Disposes of the underlying stream.
Creates a instance created from a WAV file.
The name of the WAV file.
The WaveData instance created from a WAV file.
Creates a instance created from a WAV stream.
The WAV stream. The data in the stream must include all headers that would be present in a WAV file.
The WaveData instance created from a WAV stream.
This method is similar to the constructor,
however this method will first search the stream for a format chunk in order to set
up the WaveData object with proper format info.
Gets the format of the wave data.
Gets the underlying stream providing wave data.
Typical samples rates supported by wave files.
Quantization of the analog waveform, or signal, is a real-time process operating over a continuous
time-period which produces a “stream” of digital values. In order for the process to work you must
define the rate at which new digital values are measured, or sampled, from the analog signal. The
rate at which new values are measured is called the “sampling rate” (a.k.a., the sampling frequency).
Audio based Compact Discs use a sampling rate of 44,100 Hz; this means the the Nyquist frequency is
22,050 Hz (i.e., the upper bound on the highest frequency that the digital data can clearly represent
without aliasing). This sample rate selection was no accident as the range of hearing for a healthy
young person is approximately 20 to 20,000 Hz.
In plain English, higher sampling rates will equate to higher quality sound reproduction but anything
above 44,100 Hz will not be perceived as better quality by normal human beings.
8000 samples per second
11025 samples per second
12000 samples per second
16000 samples per second
22050 samples per second
24000 samples per second
32000 samples per second
44100 samples per second
This is the standard setting for CD audio quality
48000 samples per second
Typical bit sizes supported by wave files.
Strictly speaking, “bits-per-sample” describes the total number of bits used
to encode the amplitude (or volume) of a sampled signal. The following table
describes a few typical bit ranges and their possible resolution:
Bit range
Resolution
-
8-bits (1 Byte)
0 to 255
-
16-bits (2 Bytes)
-32,768 to 32,767
-
24-bits (3 Bytes)
-8,388,608 to 8,388,607
-
32-bits (4 Bytes)
-2,147,483,648 to 2,147,483,647
The net result is that more bits you use, the more resolution you can achieve in
amplitude; hence “more bits = better sound quality” however you have to compromise
for technical constraints because “more bits = more required space”.
8-bits per sample
16-bits per sample
This is the standard setting for CD audio quality
24-bits per sample
32-bits per sample
Typical number of data channels used by wave files.
These are some common number of data channels, but wave files can support any number of data channels.
Defines a single (monaural) data sample channel
Defines two (stereo) data sample channels
This is the standard setting for CD audio quality
Defines three data sample channels
3.0 Channel Surround (analog matrixed: Dolby Surround)
Defines four data sample channels
4.0 Channel Surround (analog matrixed: Dolby Pro Logic)
Defines six data sample channels
5.1 Channel Surround (digital discrete: Dolby Digital, DTS, SDDS)
Common WAVE audio encoding formats.
Microsoft defines more than 130 different audio encoding formats for WAVE files. Only the
more common formats are defined here.
Note that PCM (i.e., Pulse Code Modulation) is a universal audio encoding format. It is a
very common method of storing and transmitting uncompressed digital audio. Since it is a
generic format, it can be read by most any audio application similar to the way a plain text
file can be read by any word-processing program. PCM is used by Audio CDs and digital audio
tapes (DATs). PCM is also a very common format for AIFF and WAV files.
Wave format type is undefined.
Standard pulse-code modulation audio format
Adaptive differential pulse-code modulation encoding algorithm
Floating point PCM encoding algorithm
A-law encoding algorithm (used in Europe and the rest of the world)
μ-law encoding algorithm (used in North America and Japan)
Decode Timestamp encoding algorithm (used in MPEG-coded multimedia)
Digital Rights Management encoded format (for digital-audio content protected by Microsoft DRM).
MPEG Audio is a family of open standards for compressed audio that includes MP2, MP3 and AAC.
ISO MPEG-Layer 3 audio format.
Use WAVEFORMATEXTENSIBLE structure.
This wave file format is used to identify multiple channels in the wave file for spatial positioning
of speakers, see for more details.
Represents the format chunk in a WAVE media format file.
RIFF type ID for wave format chunk (i.e., "fmt ").
Constructs a new using the specified audio parameters.
Sample rate for the .
Bits per sample for the .
Audio channels for the .
Audio format for the .
Invalid bit rate specified - wave file bit rates must be a multiple of 8.
Reads a new from the specified stream.
Pre-parsed header.
Source stream to read data from.
WAVE format or extra parameters section too small, wave file corrupted.
Invalid bit rate encountered - wave file bit rates must be a multiple of 8.
Parses object by parsing the specified containing a binary image.
Buffer containing binary image to parse.
0-based starting index in the to start parsing.
Valid number of bytes within from .
The number of bytes used for initialization in the (i.e., the number of bytes parsed).
WAVE format section too small, wave file corrupted.
is null.
or is less than 0 -or-
and will exceed length.
Generates a binary representation of this and copies it into the given buffer.
Buffer used to hold generated binary image of the source object.
0-based starting index in the to start writing.
The number of bytes written to the .
is null.
or is less than 0 -or-
and will exceed length.
Creates a copy of the .
A new copy of the .
Determines sample data type code based on defined
and .
Sample type code based on defined and
.
Casts sample value to its equivalent native type based on defined
and .
Sample value.
Sample value cast to its equivalent native type based on defined
and .
Size of .
Gets the length of .
Gets or sets audio format used by the .
PCM = 1 (i.e., linear quantization), values other than 1 typically indicate some form of compression.
See enumeration for more details.
Gets or sets number of audio channels in the .
This property defines the number of channels (e.g., mono = 1, stereo = 2, etc.) defined
in each sample block. See enumeration for more details.
Gets or sets the sample rate (i.e., the number of samples per second) defined in the .
This property defines the number of samples per second defined in each second of data in
the . See enumeration for more details.
Gets or sets the byte rate used for buffer estimation.
This property is not usually changed. It will be automatically calculated for new wave files.
This is typically just the arithmetic result of:
* * / 8.
However, this value can be changed as needed to accommodate better buffer estimations during
data read cycle.
Gets or sets the block size of a complete sample of data (i.e., samples for all channels of data at
one instant in time).
This property is not usually changed. It will be automatically calculated for new wave files.
This is typically just the arithmetic result of:
* / 8.
However, this value can be changed as needed to accommodate even block-alignment of non-standard
values.
Gets or sets number of bits-per-sample in the .
This property defines the number of bits-per-sample (e.g., 8, 16, 24, 32, etc.) used
by each sample in a block of samples - effectively the data sample size. See
enumeration for more details.
Gets the size of the buffer, if defined.
Gets or sets any extra parameters defined in the format header of the .
See the class for an example of usage of this property.
Spatial positioning flags for property.
Speaker positions undefined.
Front left speaker position.
Front right speaker position.
Front center speaker position.
Low frequency speaker.
Back left speaker position.
back right speaker position.
Front left of center speaker position.
Front right of center speaker position.
Back center speaker position.
Side left speaker position.
Side right speaker position.
Top center speaker position.
Top front left speaker position.
Top front center speaker position.
Top front right speaker position.
Top back left speaker position.
Top back center speaker position.
Top back right speaker position.
Reserved flags for enumeration.
All Speaker positions defined.
Common sub-type GUID's for property.
Standard pulse-code modulation audio format
PCM (Pulse Code Modulation) is a common method of storing and transmitting uncompressed digital audio.
Since it is a generic format, it can be read by most audio applications—similar to the way a plain text
file can be read by any word-processing program. PCM is used by Audio CDs and digital audio tapes (DATs).
PCM is also a very common format for AIFF and WAV files.
Adpative differential pulse-code modulation encoding algorithm
Floating point PCM encoding algorithm
Digital Rights Management encoded format (for digital-audio content protected by Microsoft DRM).
A-law encoding algorithm (used in Europe and the rest of the world)
μ-law encoding algorithm (used in North America and Japan)
MPEG Audio is a family of open standards for compressed audio that includes MP2, MP3 and AAC.
Analog sub-format.
Represents the "extensible" format structure for a WAVE media format file.
For some special bit-encodings you may need to use the "WaveFormatExtensible" audio format,
here is an example of how to use that format:
using System;
using GSF.Media;
using GSF.Media.Sound;
static class Program
{
static void Main()
{
// Generate an 8000 Hz, 32 bits per sample, mono channeled WAVE file in "Extensible" format
WaveFile waveFile = new WaveFile(8000, 32, 1, (ushort)WaveFormat.WaveFormatExtensible);
// Apply the "WaveFormatExtensible" extra parameters
WaveFormatExtensible extensible = new WaveFormatExtensible(waveFile.FormatChunk);
waveFile.ExtraParameters = extensible.BinaryImage;
// Generate the EBS Alert noise
DTMF.Generate(waveFile, DTMF.EmergencyBroadcastSystemAlert, 0.25D);
// Save the generated tone
waveFile.Save("ExtensibleTest.wav");
Console.Write("File available to be played from Windows Media Player...");
Console.ReadKey();
}
}
The fixed byte length of a instance.
Creates a new .
Creates a new object based on the settings.
A format.
Creates a new object based on the given settings.
An value representing the sample value.
A object.
A value.
Parses object by parsing the specified containing a binary image.
Buffer containing binary image to parse.
0-based starting index in the to start parsing.
Valid number of bytes within from .
The number of bytes used for initialization in the (i.e., the number of bytes parsed).
is null.
or is less than 0 -or-
and will exceed length.
Generates a binary representation of this and copies it into the given buffer.
Buffer used to hold generated binary image of the source object.
0-based starting index in the to start writing.
The number of bytes written to the .
is null.
or is less than 0 -or-
and will exceed length.
Gets or sets sample value.
Gets or sets flags representing spatial locations of data channels (i.e., speaker locations).
Gets or sets for sub-format type of extensible WaveFile.
Gets the length of the binary representation of this instance.