public void StartAudioOutput(Discord.Audio.AudioInStream audioInStream)
{
AudioInStream = audioInStream;
// 音声出力用のオーディオグラフ入力ノードを作成
// Note: Channels = 2 かつ BitRateがDisocrdに合わせて16bitじゃなきゃダメ
#region DO NOT TOUCH
_FrameInputNode = _AudioGraph.CreateFrameInputNode(
AudioEncodingProperties.CreatePcm(
OpusConvertConstants.SamplingRate,
OpusConvertConstants.Channels,
16
));
#endregion
// デフォルトの出力ノードに接続
_FrameInputNode.AddOutgoingConnection(_OutputNode);
_FrameInputNode.QuantumStarted += FrameInputNode_QuantumStarted;
_FrameInputNode.Start();
_AudioGraph.Start();
}
public async Task Init()
{
AudioGraphSettings audioGraphSettings = new AudioGraphSettings(Windows.Media.Render.AudioRenderCategory.Media);
var result = await AudioGraph.CreateAsync(audioGraphSettings);
if (result == null || result.Status != AudioGraphCreationStatus.Success)
{
return;
}
audioGraph = result.Graph;
var createAudioDeviceOutputResult = await audioGraph.CreateDeviceOutputNodeAsync();
if (createAudioDeviceOutputResult == null || createAudioDeviceOutputResult.Status != AudioDeviceNodeCreationStatus.Success)
{
return;
}
deviceOutputNode = createAudioDeviceOutputResult.DeviceOutputNode;
AudioEncodingProperties audioEncodingProperties = new AudioEncodingProperties();
audioEncodingProperties.BitsPerSample = 32;
audioEncodingProperties.ChannelCount = 2;
audioEncodingProperties.SampleRate = 44100;
audioEncodingProperties.Subtype = MediaEncodingSubtypes.Float;
audioFrameInputNode = audioGraph.CreateFrameInputNode(audioEncodingProperties);
audioFrameInputNode.QuantumStarted += FrameInputNode_QuantumStarted;
audioFrameInputNode.AddOutgoingConnection(deviceOutputNode);
audioGraph.Start();
}
private async Task InitializeAudioAsync()
{
// Create an AudioGraph with default settings
AudioGraphSettings settings = new AudioGraphSettings(AudioRenderCategory.Media);
settings.EncodingProperties = AudioEncodingProperties.CreatePcm(22050, 1, 16);
CreateAudioGraphResult result = await AudioGraph.CreateAsync(settings);
if (result.Status != AudioGraphCreationStatus.Success)
{
return;
}
_graph = result.Graph;
// Create a device output node
CreateAudioDeviceOutputNodeResult deviceOutputNodeResult = await _graph.CreateDeviceOutputNodeAsync();
if (deviceOutputNodeResult.Status != AudioDeviceNodeCreationStatus.Success)
{
return;
}
_deviceOutputNode = deviceOutputNodeResult.DeviceOutputNode;
CreateAudioDeviceInputNodeResult deviceInputNodeResult = await _graph.CreateDeviceInputNodeAsync(MediaCategory.Other);
if (deviceInputNodeResult.Status != AudioDeviceNodeCreationStatus.Success)
{
return;
}
_deviceInputNode = deviceInputNodeResult.DeviceInputNode;
// Create the FrameInputNode at the same format as the graph, except explicitly set mono.
AudioEncodingProperties nodeEncodingProperties = _graph.EncodingProperties;
nodeEncodingProperties.ChannelCount = 1;
_frameInputNode = _graph.CreateFrameInputNode(nodeEncodingProperties);
_frameInputNode.AddOutgoingConnection(_deviceOutputNode);
_frameOutputNode = _graph.CreateFrameOutputNode(nodeEncodingProperties);
_deviceInputNode.AddOutgoingConnection(_frameOutputNode);
// Initialize the Frame Input Node in the stopped state
_frameInputNode.Stop();
// Hook up an event handler so we can start generating samples when needed
// This event is triggered when the node is required to provide data
_frameInputNode.QuantumStarted += node_QuantumStarted;
_graph.QuantumProcessed += GraphOnQuantumProcessed;
// Start the graph since we will only start/stop the frame input node
_graph.Start();
}
// Creates FrameInputNode for taking in audio frames
private void CreateFrameInputNode()
{
// Create the FrameInputNode at the same format as the graph, except explicitly set mono.
AudioEncodingProperties nodeEncodingProperties = audioGraph.EncodingProperties;
frameInputNode = audioGraph.CreateFrameInputNode(nodeEncodingProperties);
// Initialize the Frame Input Node in the stopped state
frameInputNode.Stop();
// Hook up an event handler so we can start generating samples when needed
// This event is triggered when the node is required to provide data
frameInputNode.QuantumStarted += node_QuantumStarted;
}
private void CreateToxInputNode()
{
// Create the FrameInputNode at the same format as the graph, except explicitly set mono.
var nodeEncodingProperties = _audioGraph.EncodingProperties;
nodeEncodingProperties.ChannelCount = 1;
_toxInputNode = _audioGraph.CreateFrameInputNode(nodeEncodingProperties);
// Hook up an event handler so we can start generating samples when needed
// This event is triggered when the node is required to provide data
_toxInputNode.QuantumStarted += ToxInputNodeQuantumStartedHandler;
}
private void CreateNotes(int noteCount, AudioEncodingProperties props,
AudioDeviceOutputNode outputNode)
{
for (int i = 0; i < noteCount; i++)
{
double fr = 0;
if (i < 3)
{
switch (i)
{
case 0:
fr = startC;
break;
case 1:
fr = startE;
break;
case 2:
fr = startG;
break;
}
}
else
{
var theEnum = inputNotes.Values;
var lastOfNote = theEnum.ToList()[i - 3];
fr = lastOfNote.frequency * 2.0;
}
// Initialize the Frame Input Node in the stopped state
var nyQuist = graph.EncodingProperties.SampleRate / 2.0;
// Hook up an event handler so we can start generating samples when needed
// This event is triggered when the node is required to provide data
if (fr > nyQuist)
{
break; // no need to generate notes higher than
}
// the nyQuist frequency which will just sound like noise.
var inNode = graph.CreateFrameInputNode(props);
inNode.AddOutgoingConnection(outputNode);
inNode.Stop();
inNode.QuantumStarted += node_QuantumStarted;
var note = new Note(graph, inNode, fr);
inputNotes.Add(inNode, note);
}
}
private async Task CreateAudioGraph()
{
// Create an AudioGraph with default settings
AudioGraphSettings settings = new AudioGraphSettings(AudioRenderCategory.Media);
CreateAudioGraphResult result = await AudioGraph.CreateAsync(settings);
if (result.Status != AudioGraphCreationStatus.Success)
{
// Cannot create graph
rootPage.NotifyUser(String.Format("AudioGraph Creation Error because {0}", result.Status.ToString()), NotifyType.ErrorMessage);
return;
}
graph = result.Graph;
// Create a device output node
CreateAudioDeviceOutputNodeResult deviceOutputNodeResult = await graph.CreateDeviceOutputNodeAsync();
if (deviceOutputNodeResult.Status != AudioDeviceNodeCreationStatus.Success)
{
// Cannot create device output node
rootPage.NotifyUser(String.Format("Audio Device Output unavailable because {0}", deviceOutputNodeResult.Status.ToString()), NotifyType.ErrorMessage);
speakerContainer.Background = new SolidColorBrush(Colors.Red);
}
deviceOutputNode = deviceOutputNodeResult.DeviceOutputNode;
rootPage.NotifyUser("Device Output Node successfully created", NotifyType.StatusMessage);
speakerContainer.Background = new SolidColorBrush(Colors.Green);
// Create the FrameInputNode at the same format as the graph, except explicitly set mono.
AudioEncodingProperties nodeEncodingProperties = graph.EncodingProperties;
nodeEncodingProperties.ChannelCount = 1;
frameInputNode = graph.CreateFrameInputNode(nodeEncodingProperties);
frameInputNode.AddOutgoingConnection(deviceOutputNode);
frameContainer.Background = new SolidColorBrush(Colors.Green);
// Initialize the Frame Input Node in the stopped state
frameInputNode.Stop();
// Hook up an event handler so we can start generating samples when needed
// This event is triggered when the node is required to provide data
frameInputNode.QuantumStarted += node_QuantumStarted;
// Start the graph since we will only start/stop the frame input node
graph.Start();
}
private AudioGraphOutput(AudioGraph audioGraph, AudioDeviceOutputNode deviceOutputNode)
{
AudioGraph = audioGraph ?? throw new ArgumentNullException(nameof(audioGraph));
AudioEncodingProperties nodeEncodingProperties = audioGraph.EncodingProperties;
//nodeEncodingProperties.ChannelCount = Channels;
frameInputNode = audioGraph.CreateFrameInputNode(nodeEncodingProperties);
frameInputNode.AddOutgoingConnection(deviceOutputNode);
// Initialize the Frame Input Node in the stopped state
frameInputNode.Stop();
// Hook up an event handler so we can start generating samples when needed
// This event is triggered when the node is required to provide data
frameInputNode.QuantumStarted += Node_QuantumStarted;
sampleSize = sizeof(float) * AudioGraph.EncodingProperties.ChannelCount;
sampleCap = int.MaxValue - (int)(int.MaxValue % sampleSize);
}
private async Task CreateAudioGraph(uint samplingRate)
{
// Create an AudioGraph with default settings
var encoding = MediaEncodingProfile.CreateWav(AudioEncodingQuality.Auto);
encoding.Audio = AudioEncodingProperties.CreatePcm(samplingRate, 1, 16);
var settings = new AudioGraphSettings(AudioRenderCategory.Speech);
settings.EncodingProperties = encoding.Audio;
CreateAudioGraphResult result = await AudioGraph.CreateAsync(settings);
if (result.Status != AudioGraphCreationStatus.Success)
{
return;
}
graph = result.Graph;
graph.EncodingProperties.SampleRate = samplingRate;
// Create a device output node
CreateAudioDeviceOutputNodeResult deviceOutputNodeResult = await graph.CreateDeviceOutputNodeAsync();
if (deviceOutputNodeResult.Status != AudioDeviceNodeCreationStatus.Success)
{
return;
}
deviceOutputNode = deviceOutputNodeResult.DeviceOutputNode;
// Create the FrameInputNode at the same format as the graph, except explicitly set mono.
AudioEncodingProperties nodeEncodingProperties = graph.EncodingProperties;
nodeEncodingProperties.ChannelCount = 1;
frameInputNode = graph.CreateFrameInputNode(nodeEncodingProperties);
frameInputNode.AddOutgoingConnection(deviceOutputNode);
// Initialize the Frame Input Node in the stopped state
frameInputNode.Stop();
frameInputNode.AudioFrameCompleted += FrameInputNode_AudioFrameCompleted;
//frameInputNode.QuantumStarted += node_QuantumStarted;
// Start the graph since we will only start/stop the frame input node
graph.Start();
}
private async void StartButton_Click(object sender, RoutedEventArgs e)
{
DeviceInformation SelectedDevice = DevicesBox.SelectedItem as DeviceInformation;
AudioGraphSettings settings = new AudioGraphSettings(AudioRenderCategory.Media)
{
QuantumSizeSelectionMode = QuantumSizeSelectionMode.LowestLatency
};
CreateAudioGraphResult result = await AudioGraph.CreateAsync(settings);
graph = result.Graph;
// Create a device output node
CreateAudioDeviceOutputNodeResult deviceOutputNodeResult = await graph.CreateDeviceOutputNodeAsync();
AudioDeviceOutputNode deviceOutputNode = deviceOutputNodeResult.DeviceOutputNode;
// Create a device input node using the default audio input device
CreateAudioDeviceInputNodeResult deviceInputNodeResult = await graph.CreateDeviceInputNodeAsync(MediaCategory.Other, graph.EncodingProperties, SelectedDevice);
if (deviceInputNodeResult.Status != AudioDeviceNodeCreationStatus.Success)
{
// Cannot create device input node
System.Diagnostics.Debug.WriteLine(String.Format("Audio Device Input unavailable because {0}", deviceInputNodeResult.Status.ToString()));
return;
}
AudioDeviceInputNode deviceInputNode = deviceInputNodeResult.DeviceInputNode;
frameOutputNode = graph.CreateFrameOutputNode();
deviceInputNode.AddOutgoingConnection(frameOutputNode);
AudioFrameInputNode frameInputNode = graph.CreateFrameInputNode();
frameInputNode.AddOutgoingConnection(deviceOutputNode);
// Attach to QuantumStarted event in order to receive synchronous updates from audio graph (to capture incoming audio).
graph.QuantumStarted += GraphOnQuantumProcessed;
graph.Start();
}
/// <summary>
/// Setup an AudioGraph with PCM input node and output for media playback
/// </summary>
private async Task CreateAudioGraph()
{
AudioGraphSettings graphSettings = new AudioGraphSettings(Windows.Media.Render.AudioRenderCategory.Media);
CreateAudioGraphResult graphResult = await AudioGraph.CreateAsync(graphSettings);
if (graphResult.Status != AudioGraphCreationStatus.Success)
{
UpdateUI(() =>
{
this.Messages.Add(new MessageDisplay($"Error in AudioGraph construction: {graphResult.Status.ToString()}", Sender.Other));
});
}
audioGraph = graphResult.Graph;
CreateAudioDeviceOutputNodeResult outputResult = await audioGraph.CreateDeviceOutputNodeAsync();
if (outputResult.Status != AudioDeviceNodeCreationStatus.Success)
{
UpdateUI(() =>
{
this.Messages.Add(new MessageDisplay($"Error in audio OutputNode construction: {outputResult.Status.ToString()}", Sender.Other));
});
}
outputNode = outputResult.DeviceOutputNode;
// Create the FrameInputNode using PCM format; 16kHz, 1 channel, 16 bits per sample
AudioEncodingProperties nodeEncodingProperties = AudioEncodingProperties.CreatePcm(16000, 1, 16);
frameInputNode = audioGraph.CreateFrameInputNode(nodeEncodingProperties);
frameInputNode.AddOutgoingConnection(outputNode);
// Initialize the FrameInputNode in the stopped state
frameInputNode.Stop();
// Hook up an event handler so we can start generating samples when needed
// This event is triggered when the node is required to provide data
frameInputNode.QuantumStarted += node_QuantumStarted;
audioGraph.Start();
}
public static async Task CreateDeviceOutputNode()
{
Console.WriteLine("Creating AudioGraphs");
// Create an AudioGraph with default settings
AudioGraphSettings graphsettings = new AudioGraphSettings(AudioRenderCategory.GameChat);
graphsettings.EncodingProperties = new AudioEncodingProperties();
graphsettings.EncodingProperties.Subtype = "Float";
graphsettings.EncodingProperties.SampleRate = 48000;
graphsettings.EncodingProperties.ChannelCount = 2;
graphsettings.EncodingProperties.BitsPerSample = 32;
graphsettings.EncodingProperties.Bitrate = 3072000;
CreateAudioGraphResult graphresult = await AudioGraph.CreateAsync(graphsettings);
if (graphresult.Status != AudioGraphCreationStatus.Success)
{
// Cannot create graph
return;
}
outgraph = graphresult.Graph;
// Create a device output node
CreateAudioDeviceOutputNodeResult deviceOutputNodeResult = await outgraph.CreateDeviceOutputNodeAsync();
if (deviceOutputNodeResult.Status != AudioDeviceNodeCreationStatus.Success)
{
// Cannot create device output node
}
deviceOutputNode = deviceOutputNodeResult.DeviceOutputNode;
// Create the FrameInputNode at the same format as the graph, except explicitly set stereo.
frameInputNode = outgraph.CreateFrameInputNode(outgraph.EncodingProperties);
frameInputNode.AddOutgoingConnection(deviceOutputNode);
frameInputNode.Start();
ready = true;
outgraph.Start();
}
public async Task Start()
{
m_isFlushing = false;
m_isRunning = false;
m_waveBufferReader = null;
var settings = new AudioGraphSettings(AudioRenderCategory.Media);
var result = await AudioGraph.CreateAsync(settings);
if (result.Status != AudioGraphCreationStatus.Success)
{
throw new Exception("AudioGraph creation error: " + result.Status);
}
m_audioGraph = result.Graph;
var outputDeviceResult = await m_audioGraph.CreateDeviceOutputNodeAsync();
if (outputDeviceResult.Status != AudioDeviceNodeCreationStatus.Success)
{
throw new Exception("Unable to create audio playback device: " + result.Status);
}
m_deviceOutputNode = outputDeviceResult.DeviceOutputNode;
// Create the FrameInputNode at the same format as the graph,
var nodeEncodingProperties = m_audioGraph.EncodingProperties;
nodeEncodingProperties.ChannelCount = 1;
nodeEncodingProperties.SampleRate = 16000;
m_frameInputNode = m_audioGraph.CreateFrameInputNode(nodeEncodingProperties);
m_frameInputNode.AddOutgoingConnection(m_deviceOutputNode);
m_frameInputNode.QuantumStarted += OnQuantumStarted;
m_isRunning = true;
m_isFlushing = false;
m_audioGraph.Start();
}
private async void Page_Loaded(object sender, RoutedEventArgs e)
{
// midi
var s = MidiInPort.GetDeviceSelector();
var information = await DeviceInformation.FindAllAsync(s);
var list = information.ToList();
port = await MidiInPort.FromIdAsync(list.ElementAt(2).Id);
port.MessageReceived += Port_MessageReceived;
// audio
var settings = new AudioGraphSettings(AudioRenderCategory.GameEffects);
settings.QuantumSizeSelectionMode = QuantumSizeSelectionMode.LowestLatency;
var creation = await AudioGraph.CreateAsync(settings);
graph = creation.Graph;
output = await graph.CreateDeviceOutputNodeAsync();
var encoding = graph.EncodingProperties;
encoding.ChannelCount = 1;
input = graph.CreateFrameInputNode(encoding);
input.AddOutgoingConnection(output.DeviceOutputNode);
input.Stop();
input.QuantumStarted += Input_QuantumStarted;
graph.Start();
// midi notes (pitch to note)
float a = 440; // a is 440 hz...
for (int x = 0; x < 127; ++x)
{
notes[x] = (a / 32f) * (float)Math.Pow(2f, ((x - 9f) / 12f));
}
}
SaveAudioToFile(
StorageFile file,
IProgress <string> status)
{
_finished = false;
status.Report("Saving audio to file");
var mediaEncodingProfile =
CreateMediaEncodingProfile(file);
if (!_audioData.IsStereo && mediaEncodingProfile.Audio != null)
{
mediaEncodingProfile.Audio.ChannelCount = 1;
}
// Initialize FileOutputNode
var result =
await _audioGraph.CreateFileOutputNodeAsync(file, mediaEncodingProfile);
if (result.Status != AudioFileNodeCreationStatus.Success)
{
return(result);
}
_fileOutputNode = result.FileOutputNode;
_fileOutputNode.Stop();
// Initialize FrameInputNode and connect it to fileOutputNode
_frameInputNode = _audioGraph.CreateFrameInputNode(
// EncodingProprties are different than for input file
_fileOutputNode.EncodingProperties
//audioEncodingProperties
);
_frameInputNode.AddOutgoingConnection(_fileOutputNode);
_frameInputNode.Stop();
// Add a handler which will transfer every audioData sample to audio frame
_frameInputNode.QuantumStarted += FrameInputNode_QuantumStarted;
_audioDataCurrentPosition = 0;
// Start process which will write audio file frame by frame
// and will generated events QuantumStarted
_audioGraph.Start();
// don't start fileOutputNode yet because it will record zeros
// because we initialised frameInputNode in Stop mode we need to start it
_frameInputNode.Start();
// didn't find a better way to wait for writing to file
while (!_finished)
{
await Task.Delay(50);
}
// when audioData samples ended and audioGraph already stoped
await _fileOutputNode.FinalizeAsync();
// clean status and progress
status.Report("");
_ioProgress.Report(0);
return(result);
}
/// <summary>
/// Create output audio graph
/// </summary>
/// <param name="deviceId">Overload for default ouput device id</param>
public static async Task CreateOutputDeviceNode(string deviceId = null)
{
// If not in use, redo dispose
if (outgraph != null && OutputDeviceID != outgraph.PrimaryRenderDevice.Id)
{
HeavyDisposeOutGraph();
}
// Increment use counter
else
{
outGraphCount++;
}
Console.WriteLine("Creating AudioGraphs");
// Create an AudioGraph with default settings
AudioGraphSettings graphsettings = new AudioGraphSettings(AudioRenderCategory.Media);
graphsettings.EncodingProperties = new AudioEncodingProperties();
graphsettings.EncodingProperties.Subtype = "Float";
graphsettings.EncodingProperties.SampleRate = 48000;
graphsettings.EncodingProperties.ChannelCount = 2;
graphsettings.EncodingProperties.BitsPerSample = 32;
graphsettings.EncodingProperties.Bitrate = 3072000;
// Determine selected device
DeviceInformation selectedDevice;
if (deviceId == "Default" || deviceId == null)
{
selectedDevice = await DeviceInformation.CreateFromIdAsync(Windows.Media.Devices.MediaDevice.GetDefaultAudioRenderId(Windows.Media.Devices.AudioDeviceRole.Default));
Windows.Media.Devices.MediaDevice.DefaultAudioRenderDeviceChanged += MediaDevice_DefaultAudioRenderDeviceChanged;
}
else
{
try
{
selectedDevice = await DeviceInformation.CreateFromIdAsync(deviceId);
}
catch
{
selectedDevice = await DeviceInformation.CreateFromIdAsync(Windows.Media.Devices.MediaDevice.GetDefaultAudioRenderId(Windows.Media.Devices.AudioDeviceRole.Default));
deviceId = "Default";
}
}
// Set selected device
graphsettings.PrimaryRenderDevice = selectedDevice;
// Create graph
CreateAudioGraphResult graphresult = await AudioGraph.CreateAsync(graphsettings);
if (graphresult.Status != AudioGraphCreationStatus.Success)
{
// Cannot create graph
return;
}
// "Save" graph
outgraph = graphresult.Graph;
// Create a device output node
CreateAudioDeviceOutputNodeResult deviceOutputNodeResult = await outgraph.CreateDeviceOutputNodeAsync();
if (deviceOutputNodeResult.Status != AudioDeviceNodeCreationStatus.Success)
{
// Cannot create device output node
}
deviceOutputNode = deviceOutputNodeResult.DeviceOutputNode;
// Create the FrameInputNode at the same format as the graph, except explicitly set stereo.
frameInputNode = outgraph.CreateFrameInputNode(outgraph.EncodingProperties);
frameInputNode.AddOutgoingConnection(deviceOutputNode);
OutputDeviceID = deviceId;
// Begin playing
frameInputNode.Start();
ready = true;
outgraph.Start();
}
private void CreateNotes(int noteCount, AudioEncodingProperties props,
AudioDeviceOutputNode outputNode)
{
NoteMC currentNote = null;
for (int i = 0; i < noteCount; i++)
{
double fr = 0;
if (i < 3)
{
switch (i)
{
case 0:
fr = startC;
break;
case 1:
fr = startE;
break;
case 2:
fr = startG;
break;
}
}
else
{
var lastOfNote = allFrequencyList[i - 3];
fr = lastOfNote * 2.0;
}
allFrequencyList.Add(fr);
// Initialize the Frame Input Node in the stopped state
var nyQuist = graph.EncodingProperties.SampleRate / 2.0;
// Hook up an event handler so we can start generating samples when needed
// This event is triggered when the node is required to provide data
if (fr > nyQuist)
{
break; // no need to generate notes higher than
}
// the nyQuist frequency which will just sound like noise.
if (currentNote == null ||
(currentNote.GetFrequencyCount() >= props.ChannelCount))
{
var inNode = graph.CreateFrameInputNode(props);
inNode.AddOutgoingConnection(outputNode);
inNode.Stop();
inNode.QuantumStarted += node_QuantumStarted;
currentNote = new NoteMC(graph, inNode, fr);
inputNotes.Add(inNode, currentNote);
}
else
{
currentNote.AddFrequency(fr);
currentNote.AddAngle(0.0);
}
}
}
private async Task CreateAudioGraph()
{
// Create an AudioGraph with default settings
AudioGraphSettings settings = new AudioGraphSettings(AudioRenderCategory.Media);
CreateAudioGraphResult result = await AudioGraph.CreateAsync(settings);
if (result.Status != AudioGraphCreationStatus.Success)
{
// Cannot create graph
rootPage.NotifyUser(String.Format("AudioGraph Creation Error because {0}", result.Status.ToString()), NotifyType.ErrorMessage);
return;
}
graph = result.Graph;
// Create a device output node
CreateAudioDeviceOutputNodeResult deviceOutputNodeResult = await graph.CreateDeviceOutputNodeAsync();
if (deviceOutputNodeResult.Status != AudioDeviceNodeCreationStatus.Success)
{
// Cannot create device output node
rootPage.NotifyUser(String.Format("Audio Device Output unavailable because {0}", deviceOutputNodeResult.Status.ToString()), NotifyType.ErrorMessage);
speakerContainer.Background = new SolidColorBrush(Colors.Red);
}
deviceOutputNode = deviceOutputNodeResult.DeviceOutputNode;
rootPage.NotifyUser("Device Output Node successfully created", NotifyType.StatusMessage);
speakerContainer.Background = new SolidColorBrush(Colors.Green);
// Create the FrameInputNode at the same format as the graph, except explicitly set mono.
AudioEncodingProperties nodeEncodingProperties = graph.EncodingProperties;
nodeEncodingProperties.ChannelCount = 1;
frameInputNode = graph.CreateFrameInputNode(nodeEncodingProperties);
frameInputNode.AddOutgoingConnection(deviceOutputNode);
frameContainer.Background = new SolidColorBrush(Colors.Green);
// Initialize the Frame Input Node in the stopped state
frameInputNode.Stop();
// Hook up an event handler so we can start generating samples when needed
// This event is triggered when the node is required to provide data
frameInputNode.QuantumStarted += node_QuantumStarted;
// Start the graph since we will only start/stop the frame input node
graph.Start();
}
private async void InitializeAsync()
{
await UpdatePlaylistAsync();
MasterVolume = 100;
await AudioSourceManager.InitializeAsync(new FileSystem(), "GroorineCore");
var settings = new AudioGraphSettings(AudioRenderCategory.Media)
{
};
CreateAudioGraphResult result = await AudioGraph.CreateAsync(settings);
if (result.Status != AudioGraphCreationStatus.Success)
{
await new MessageDialog("Can't create AudioGraph! Application will stop...").ShowAsync();
Application.Current.Exit();
}
_graph = result.Graph;
CreateAudioDeviceOutputNodeResult deviceOutputNodeResult = await _graph.CreateDeviceOutputNodeAsync();
if (deviceOutputNodeResult.Status != AudioDeviceNodeCreationStatus.Success)
{
await new MessageDialog("Can't create DeviceOutputNode! Application will stop...").ShowAsync();
Application.Current.Exit();
}
_deviceOutputNode = deviceOutputNodeResult.DeviceOutputNode;
AudioEncodingProperties nodeEncodingProperties = _graph.EncodingProperties;
nodeEncodingProperties.ChannelCount = 2;
_frameInputNode = _graph.CreateFrameInputNode(nodeEncodingProperties);
_frameInputNode.AddOutgoingConnection(_deviceOutputNode);
_frameInputNode.Stop();
_player = new Player((int)nodeEncodingProperties.SampleRate);
_player.PropertyChanged += (sender, args) =>
{
switch (args.PropertyName)
{
case nameof(_player.IsPlaying):
_synchronizationContext.Post(o =>
{
if (!_player.IsPlaying && !_player.IsPausing && IsPlaying)
{
IsPlaying = CanStop = false;
}
}, null);
break;
}
};
_frameInputNode.QuantumStarted += (sender, args) =>
{
var numSamplesNeeded = (uint)args.RequiredSamples;
if (numSamplesNeeded != 0)
{
//_synchronizationContext.Post(o =>
//{
// foreach (var a in Channels)
// a.Update();
AudioFrame audioData = GenerateAudioData(numSamplesNeeded);
_frameInputNode.AddFrame(audioData);
//}, null);
}
};
_graph.Start();
_frameInputNode.Start();
/*
* _player = new Player();
*
* _buffer = _player.CreateBuffer(50);
*
* _bwp = new BufferedWaveProvider(new WaveFormat(44100, 16, 2));
* _nativePlayer = new WasapiOutRT(AudioClientShareMode.Shared, 50);
* _nativePlayer.Init(() => _bwp);
* _nativePlayer.Play();
*/
IsInitialized = true;
/*
* while (true)
* {
* _player.GetBuffer(_buffer);
*
* var b = ToByte(_buffer);
* _bwp.AddSamples(b, 0, b.Length);
* while (_bwp.BufferedBytes > _buffer.Length * 2)
* await Task.Delay(1);
* }
*/
}
void ISynthesizer.SetUp()
{
using (WavePlayer player = WavePlayer.CreateWavePlayer())
{
}
AudioGraphSettings settings = new AudioGraphSettings(AudioRenderCategory.Media)
{
//QuantumSizeSelectionMode = QuantumSizeSelectionMode.LowestLatency
};
AudioGraph.CreateAsync(settings).AsTask().ContinueWith(graphTask =>
{
CreateAudioGraphResult graphResult = graphTask.Result;
if(graphResult.Status != AudioGraphCreationStatus.Success)
{
this.EmitFailed();
}
else
{
graphResult.Graph.CreateDeviceOutputNodeAsync().AsTask().ContinueWith(nodeTask =>
{
CreateAudioDeviceOutputNodeResult nodeResult = nodeTask.Result;
if(nodeResult.Status != AudioDeviceNodeCreationStatus.Success)
{
this.EmitFailed();
}
else
{
_audioGraph = graphResult.Graph;
_frameInputNode = _audioGraph.CreateFrameInputNode();
_frameInputNode.AddOutgoingConnection(nodeResult.DeviceOutputNode);
_frameInputNode.QuantumStarted += this.OnQuantumStarted;
_channelsNumber = _audioGraph.EncodingProperties.ChannelCount;
_waveSource = new WaveSource(_audioGraph.EncodingProperties.SampleRate, _channelsNumber);
this.EmitReady();
}
});
}
});
}