uint TapProc(AudioQueueProcessingTap audioQueueTap, uint inNumberOfFrames, ref AudioTimeStamp timeStamp, ref AudioQueueProcessingTapFlags flags, AudioBuffers data)
{
AudioQueueProcessingTapFlags sourceFlags;
uint sourceFrames;
if (audioQueueTap.GetSourceAudio(inNumberOfFrames, ref timeStamp, out sourceFlags, out sourceFrames, data) != AudioQueueStatus.Ok)
{
throw new ApplicationException();
}
for (int channel = 0; channel < data.Count; channel++)
{
preRenderData[channel] = data [channel].Data;
data.SetData(channel, IntPtr.Zero);
}
renderTimeStamp.Flags = AudioTimeStamp.AtsFlags.SampleTimeValid;
AudioUnitRenderActionFlags actionFlags = 0;
AudioUnitStatus res = genericOutputUnit.Render(ref actionFlags, renderTimeStamp, 0, inNumberOfFrames, data);
if (res != AudioUnitStatus.NoError)
{
throw new ApplicationException();
}
return(sourceFrames);
}
static extern int AudioUnitRender(IntPtr inUnit,
ref AudioUnitRenderActionFlags ioActionFlags,
ref AudioTimeStamp inTimeStamp,
UInt32 inOutputBusNumber,
UInt32 inNumberFrames,
AudioBufferList ioData
);
static AudioUnitStatus renderCallback(IntPtr inRefCon,
ref AudioUnitRenderActionFlags _ioActionFlags,
ref AudioTimeStamp _inTimeStamp,
uint _inBusNumber,
uint _inNumberFrames,
IntPtr _ioData)
{
// getting audiounit instance
var handler = GCHandle.FromIntPtr(inRefCon);
var inst = (AUGraph)handler.Target;
HashSet <RenderDelegate> renderers = inst.graphUserCallbacks;
if (renderers.Count != 0)
{
using (var buffers = new AudioBuffers(_ioData)) {
foreach (RenderDelegate renderer in renderers)
{
renderer(_ioActionFlags, _inTimeStamp, _inBusNumber, _inNumberFrames, buffers);
}
return(AudioUnitStatus.OK);
}
}
return(AudioUnitStatus.InvalidParameter);
}
static int renderCallback(IntPtr inRefCon,
ref AudioUnitRenderActionFlags _ioActionFlags,
ref AudioTimeStamp _inTimeStamp,
uint _inBusNumber,
uint _inNumberFrames,
AudioBufferList _ioData)
{
//System.Diagnostics.Debug.WriteLine(_ioActionFlags);
// getting audiounit instance
var handler = GCHandle.FromIntPtr(inRefCon);
var inst = (AudioUnit)handler.Target;
// evoke event handler with an argument
if (inst._renderEvent != null)
{
var args = new AudioUnitEventArgs(
_ioActionFlags,
_inTimeStamp,
_inBusNumber,
_inNumberFrames,
_ioData);
inst._renderEvent(inst, args);
}
return(0); // noerror
}
static AudioUnitStatus RenderCallbackImpl(IntPtr clientData, ref AudioUnitRenderActionFlags actionFlags, ref AudioTimeStamp timeStamp, uint busNumber, uint numberFrames, IntPtr data)
{
GCHandle gch = GCHandle.FromIntPtr(clientData);
var au = (AudioUnit)gch.Target;
return(au.render(actionFlags, timeStamp, busNumber, numberFrames, new AudioBuffers(data)));
}
static int oldRenderCallback(IntPtr inRefCon,
ref AudioUnitRenderActionFlags _ioActionFlags,
ref AudioTimeStamp _inTimeStamp,
int _inBusNumber,
int _inNumberFrames,
AudioBufferList _ioData)
{
// getting audiounit instance
var handler = GCHandle.FromIntPtr(inRefCon);
var inst = (AUGraph)handler.Target;
// invoke event handler with an argument
if (inst.RenderCallback != null)
{
var args = new AudioGraphEventArgs(
_ioActionFlags,
_inTimeStamp,
_inBusNumber,
_inNumberFrames,
_ioData);
inst.RenderCallback(inst, args);
}
return(0); // noerror
}
uint TapProc(AudioQueueProcessingTap audioQueueTap, uint numberOfFrames, ref AudioTimeStamp timeStamp, ref AudioQueueProcessingTapFlags flags, AudioBuffers data)
{
AudioQueueProcessingTapFlags source_flags;
uint source_frames;
if (audioQueueTap.GetSourceAudio(numberOfFrames, ref timeStamp, out source_flags, out source_frames, data) != AudioQueueStatus.Ok)
{
throw new ApplicationException();
}
preRenderData = data [0].Data;
data.SetData(0, IntPtr.Zero);
var renderTimeStamp = new AudioTimeStamp();
renderTimeStamp.Flags = AudioTimeStamp.AtsFlags.SampleTimeValid;
AudioUnitRenderActionFlags action_flags = 0;
var res = genericOutputUnit.Render(ref action_flags, renderTimeStamp, 0, numberOfFrames, data);
if (res != AudioUnitStatus.NoError)
{
throw new ApplicationException();
}
return(source_frames);
}
static int renderCallback(IntPtr inRefCon,
ref AudioUnitRenderActionFlags _ioActionFlags,
ref AudioTimeStamp _inTimeStamp,
uint _inBusNumber,
uint _inNumberFrames,
AudioBufferList _ioData)
{
//System.Diagnostics.Debug.WriteLine(_ioActionFlags);
// getting audiounit instance
var handler = GCHandle.FromIntPtr(inRefCon);
var inst = (AudioUnit)handler.Target;
// evoke event handler with an argument
if (inst._renderEvent != null)
{
var args = new AudioUnitEventArgs(
_ioActionFlags,
_inTimeStamp,
_inBusNumber,
_inNumberFrames,
_ioData);
inst._renderEvent(inst, args);
}
return 0; // noerror
}
public AudioGraphEventArgs(AudioUnitRenderActionFlags actionFlags,
MonoMac.AudioToolbox.AudioTimeStamp timeStamp,
int busNumber,
int numberFrames,
AudioBufferList data)
: base(actionFlags, timeStamp, busNumber, numberFrames, data)
{
}
public AudioGraphEventArgs(AudioUnitRenderActionFlags actionFlags,
MonoMac.AudioToolbox.AudioTimeStamp timeStamp,
int busNumber,
int numberFrames,
AudioBufferList data)
: base(actionFlags, timeStamp, busNumber, numberFrames, data)
{
}
public AudioUnitStatus PullInput (ref AudioUnitRenderActionFlags actionFlags, AudioTimeStamp timestamp, uint frameCount, int inputBusNumber, AURenderPullInputBlock pullInputBlock)
{
if (pullInputBlock == null)
return AudioUnitStatus.NoConnection;
PrepareInputBufferList ();
AudioUnitStatus s = pullInputBlock (ref actionFlags, ref timestamp, frameCount, inputBusNumber, MutableAudioBufferList);
return s;
}
AudioUnitStatus ConvertInputRenderCallback(AudioUnitRenderActionFlags actionFlags, AudioTimeStamp timeStamp, uint busNumber, uint numberFrames, AudioBuffers data)
{
renderTimeStamp.SampleTime += numberFrames;
for (int channel = 0; channel < data.Count; channel++)
{
data.SetData(channel, preRenderData [channel]);
}
return(AudioUnitStatus.NoError);
}
AudioUnitStatus RenderCallback(AudioUnitRenderActionFlags actionFlags, AudioTimeStamp timeStamp, uint busNumber, uint numberFrames, AudioBuffers data)
{
// getting microphone input signal
audioUnit.Render(ref actionFlags, timeStamp, 1, numberFrames, data);
// Getting a pointer to a buffer to be filled
IntPtr outL = data [0].Data;
IntPtr outR = data [1].Data;
// Getting signal level
// https://en.wikipedia.org/wiki/Root_mean_square
float sqrSum = 0;
for (int j = 0; j < numberFrames; j++)
{
float v = Marshal.ReadInt16(outL, j * sizeof(Int16));
sqrSum += (v * v);
}
SignalLevel = (float)Math.Sqrt(sqrSum / numberFrames);
if (triggered <= 0 && SignalLevel > Threshold)
{
triggered = FramesToPlay;
}
// playing sound
unsafe {
var outLPtr = (int *)outL.ToPointer();
var outRPtr = (int *)outR.ToPointer();
for (int i = 0; i < numberFrames; i++)
{
triggered = Math.Max(0, triggered - 1);
if (triggered > 0)
{
var buf0 = (int *)buffer [0].Data;
var buf1 = (int *)buffer [numberOfChannels - 1].Data;
++CurrentFrame;
*outLPtr++ = buf0 [currentFrame];
*outRPtr++ = buf1 [currentFrame];
}
else
{
// 0-filling
*outLPtr++ = 0;
*outRPtr++ = 0;
}
}
}
return(AudioUnitStatus.NoError);
}
public AudioUnitStatus TryRender(AudioUnitRenderActionFlags flags,
AudioTimeStamp timeStamp,
int outputBusnumber,
int numberFrames, AudioBufferList data)
{
return((AudioUnitStatus)AudioUnitRender(handle,
ref flags,
ref timeStamp,
outputBusnumber,
numberFrames,
data));
}
public AudioUnitEventArgs(AudioUnitRenderActionFlags actionFlags,
AudioTimeStamp timestamp,
int busNumber,
int frames,
AudioBufferList data)
{
ActionFlags = actionFlags;
this.TimeStamp = timestamp;
BusNumber = busNumber;
NumberFrames = frames;
Data = data;
}
public AudioUnitEventArgs(AudioUnitRenderActionFlags actionFlags,
MonoMac.AudioToolbox.AudioTimeStamp timestamp,
int busNumber,
int frames,
AudioBufferList data)
{
ActionFlags = actionFlags;
this.TimeStamp = timestamp;
BusNumber = busNumber;
NumberFrames = frames;
Data = data;
}
public AudioUnitStatus PullInput(ref AudioUnitRenderActionFlags actionFlags, AudioTimeStamp timestamp, uint frameCount, int inputBusNumber, AURenderPullInputBlock pullInputBlock)
{
if (pullInputBlock == null)
{
return(AudioUnitStatus.NoConnection);
}
PrepareInputBufferList();
AudioUnitStatus s = pullInputBlock(ref actionFlags, ref timestamp, frameCount, inputBusNumber, MutableAudioBufferList);
return(s);
}
public void Render(AudioUnitRenderActionFlags flags, AudioTimeStamp timeStamp, UInt32 outputBusnumber, UInt32 numberFrames, AudioBufferList data)
{
int err = AudioUnitRender(_audioUnit,
ref flags,
ref timeStamp,
outputBusnumber,
numberFrames,
data);
if (err != 0)
{
throw new InvalidOperationException(String.Format("Error code:{0}", err));
}
}
AudioUnitStatus Render(AudioUnitRenderActionFlags actionFlags, AudioTimeStamp timeStamp, uint busNumber, uint numberFrames, AudioBuffers data)
{
// Just return audio buffers from MTAudioProcessingTap.
MTAudioProcessingTapFlags flags;
CMTimeRange range;
nint n;
var error = (AudioUnitStatus)(int)audioProcessingTap.GetSourceAudio((nint)numberFrames, data, out flags, out range, out n);
if (error != AudioUnitStatus.NoError)
{
Console.WriteLine("{0} audioProcessingTap.GetSourceAudio failed", error);
}
return(error);
}
/// <summary>
/// Renders the mixer node. Orchestrates dynamic changes to tempo and beatcode.
/// </summary>
/// <returns>The render delegate.</returns>
/// <param name="actionFlags">Action flags.</param>
/// <param name="timeStamp">Time stamp.</param>
/// <param name="busNumber">Bus number.</param>
/// <param name="numberFrames">Number frames.</param>
/// <param name="data">Data.</param>
unsafe AudioUnitStatus MixerRenderDelegate(AudioUnitRenderActionFlags actionFlags, AudioTimeStamp timeStamp, uint busNumber, uint numberFrames, AudioBuffers data)
{
if (busNumber >= Streams.Count)
{
// this prevents the buffer from doubling up with unused buses
return(AudioUnitStatus.InvalidElement);
}
var outLeft = (float *)data[0].Data;
var outRight = (float *)data[1].Data;
// if theres a count-off, we read from the countoff source
if (CountOffSampleDuration > 0)
{
// skip all inputs but the last one so that non-count off cycle starts with bus 0
if (busNumber != Streams.Count - 1)
{
return(AudioUnitStatus.InvalidElement);
}
var stream = Streams[(int)busNumber];
//if (stream.IsMuted)
//{
// EnableInput(stream, true);
//}
_countOff.Read(outLeft, outRight, numberFrames);
CountOffSampleDuration -= numberFrames;
// set elapsed bpm and cycles to 0
if (CountOffSampleDuration == 0)
{
Metronome.Instance.ElapsedBpm -= Metronome.Instance.ConvertSamplesToBpm(_countOffTotal);
cycle = -1;
EnableInput(stream, !stream.IsMuted);
}
return(AudioUnitStatus.OK);
}
IStreamProvider source = Streams[(int)busNumber];
source.Read(outLeft, outRight, numberFrames);
return(AudioUnitStatus.OK);
}
static AudioUnitStatus RenderCallbackImpl(IntPtr clientData, ref AudioUnitRenderActionFlags actionFlags, ref AudioTimeStamp timeStamp, uint busNumber, uint numberFrames, IntPtr data)
{
GCHandle gch = GCHandle.FromIntPtr(clientData);
var au = (AUGraph)gch.Target;
RenderDelegate callback;
if (!au.nodesCallbacks.TryGetValue(busNumber, out callback))
{
return(AudioUnitStatus.InvalidParameter);
}
using (var buffers = new AudioBuffers(data)) {
return(callback(actionFlags, timeStamp, busNumber, numberFrames, buffers));
}
}
public void Render(AudioUnitRenderActionFlags flags,
AudioTimeStamp timeStamp,
int outputBusnumber,
int numberFrames, AudioBufferList data)
{
int err = AudioUnitRender(handle,
ref flags,
ref timeStamp,
outputBusnumber,
numberFrames,
data);
if (err != 0)
{
throw new AudioUnitException(err);
}
}
AudioUnitStatus RenderCallback(AudioUnitRenderActionFlags actionFlags, AudioTimeStamp timeStamp, uint busNumber, uint numberFrames, AudioBuffers data)
{
// getting microphone input signal
audioUnit.Render (ref actionFlags, timeStamp, 1, numberFrames, data);
// Getting a pointer to a buffer to be filled
IntPtr outL = data [0].Data;
IntPtr outR = data [1].Data;
// Getting signal level
// https://en.wikipedia.org/wiki/Root_mean_square
float sqrSum = 0;
for (int j = 0; j < numberFrames; j++) {
float v = Marshal.ReadInt16(outL, j * sizeof(Int16));
sqrSum += (v * v);
}
SignalLevel = (float)Math.Sqrt (sqrSum / numberFrames);
if (triggered <= 0 && SignalLevel > Threshold)
triggered = FramesToPlay;
// playing sound
unsafe {
var outLPtr = (int*)outL.ToPointer ();
var outRPtr = (int*)outR.ToPointer ();
for (int i = 0; i < numberFrames; i++) {
triggered = Math.Max (0, triggered - 1);
if (triggered > 0) {
var buf0 = (int*)buffer [0].Data;
var buf1 = (int*)buffer [numberOfChannels - 1].Data;
++CurrentFrame;
*outLPtr++ = buf0 [currentFrame];
*outRPtr++ = buf1 [currentFrame];
} else {
// 0-filling
*outLPtr++ = 0;
*outRPtr++ = 0;
}
}
}
return AudioUnitStatus.NoError;
}
AudioUnitStatus _audioUnit_RenderCallback(AudioUnitRenderActionFlags actionFlags, AudioTimeStamp timeStamp, uint busNumber, uint numberFrames, AudioBuffers data)
{
if (_processBlockEventHandler != null)
{
if (_processBlockArgs == null ||
_processBlockArgs.ChannelCount != _audioFormat.ChannelsPerFrame ||
_processBlockArgs.NumberOfFrames != numberFrames)
{
_processBlockArgs = new NativeProcessBlockEventArgs((int)numberFrames, _audioFormat.ChannelsPerFrame);
}
_processBlockArgs.AudioBuffers = data;
_processBlockEventHandler(this, _processBlockArgs);
//_processBlockArgs.ReturnInterleavedBuffer ();
_processBlockArgs.ReturnNonInterleavedBuffer();
}
return(AudioUnitStatus.NoError);
}
public AudioUnitStatus InternalRenderBlockProc(ref AudioUnitRenderActionFlags actionFlags, ref AudioTimeStamp timestamp, uint frameCount, nint outputBusNumber, AudioBuffers outputData, AURenderEventEnumerator realtimeEventListHead, AURenderPullInputBlock pullInputBlock)
{
var transportStateFlags = (AUHostTransportStateFlags)0;
double currentSamplePosition = 0;
double cycleStartBeatPosition = 0;
double cycleEndBeatPosition = 0;
var callBack = TransportStateBlock;
if (callBack != null)
{
callBack(ref transportStateFlags, ref currentSamplePosition, ref cycleStartBeatPosition, ref cycleEndBeatPosition);
}
var state = Kernel;
var input = inputBus;
var pullFlags = (AudioUnitRenderActionFlags)0;
AudioUnitStatus err = input.PullInput(ref pullFlags, timestamp, frameCount, 0, pullInputBlock);
if (err != AudioUnitStatus.NoError)
{
return(err);
}
AudioBuffers inAudioBufferList = input.MutableAudioBufferList;
if (outputData [0].Data == IntPtr.Zero)
{
for (int i = 0; i < outputData.Count; i++)
{
outputData.SetData(i, inAudioBufferList [i].Data);
}
}
state.SetBuffers(inAudioBufferList, outputData);
state.ProcessWithEvents(timestamp, (int)frameCount, realtimeEventListHead);
return(AudioUnitStatus.NoError);
}
unsafe AudioUnitStatus HandleRenderDelegate(AudioUnitRenderActionFlags actionFlags, AudioTimeStamp timeStamp, uint busNumber, uint numberFrames, AudioBuffers data)
{
var sndbuf = soundBuffer [busNumber];
var sample = sndbuf.SampleNum; // frame number to start from
var bufSamples = sndbuf.TotalFrames; // total number of frames in the sound buffer
var input = (int *)sndbuf.Data;
var outA = (int *)data [0].Data; // output audio buffer for L channel
var outB = (int *)data [1].Data; // output audio buffer for R channel
// for demonstration purposes we've configured 2 stereo input busses for the mixer unit
// but only provide a single channel of data from each input bus when asked and silence for the other channel
// alternating as appropriate when asked to render bus 0 or bus 1's input
for (var i = 0; i < numberFrames; ++i)
{
if (busNumber == 1)
{
outA [i] = 0;
outB [i] = input [sample++];
}
else
{
outA [i] = input[sample++];
outB [i] = 0;
}
if (sample > bufSamples)
{
// start over from the beginning of the data, our audio simply loops
Debug.Print("Looping data for bus {0} after {1} source frames rendered", busNumber, sample - 1);
sample = 0;
}
}
// keep track of where we are in the source data buffer
sndbuf.SampleNum = sample;
return(AudioUnitStatus.OK);
}
AudioUnitStatus AudioInputCallBack(AudioUnitRenderActionFlags actionFlags, AudioTimeStamp timeStamp, uint busNumber, uint numberFrames, AudioUnit audioUnit)
{
var buffer = new AudioBuffer()
{
NumberChannels = 1,
DataByteSize = (int)numberFrames * 2,
Data = System.Runtime.InteropServices.Marshal.AllocHGlobal((int)numberFrames * 2)
};
var bufferList = new AudioBuffers(1);
bufferList[0] = buffer;
var status = audioUnit.Render(ref actionFlags, timeStamp, busNumber, numberFrames, bufferList);
var send = new byte[buffer.DataByteSize];
System.Runtime.InteropServices.Marshal.Copy(buffer.Data, send, 0, send.Length);
var handler = DataAvailable;
if (handler != null)
{
handler(this, send);
}
Console.Write("\n Buffer: ");
foreach (byte b in send)
{
Console.Write("\\x" + b);
}
Console.Write("\n");
System.Runtime.InteropServices.Marshal.FreeHGlobal(buffer.Data);
return(AudioUnitStatus.OK);
}
AudioUnitStatus InputCallback(AudioUnitRenderActionFlags actionFlags, AudioTimeStamp timeStamp, uint busNumber, uint numberFrames, global::AudioUnit.AudioUnit audioUnit)
{
inputCallbackEvent.Set();
return(AudioUnitStatus.NoError);
}
unsafe AudioUnitStatus AudioUnit_RenderCallback(AudioUnitRenderActionFlags actionFlags,
AudioTimeStamp timeStamp, uint busNumber, uint numberFrames, AudioBuffers data)
{
_clock.Restart();
AudioUnitStatus err = AudioUnitStatus.OK;
if (_audioInputIsAvailable && _numInputChannels > 0)
{
err = _audioUnit.Render(ref actionFlags, timeStamp, 1, numberFrames, data);
}
var dataPtr = data[0].Data;
if (_callback != null)
{
if (numberFrames > _sampleBuffer.NumSamples)
{
PrepareFloatBuffers((int)numberFrames);
}
if (_audioInputIsAvailable && _numInputChannels > 0)
{
var shortData = (short *)dataPtr.ToPointer();
if (_numInputChannels >= 2)
{
float *leftInput = _inputChannels[0];
float *rightInput = _inputChannels[1];
for (var i = 0; i < numberFrames; ++i)
{
*leftInput++ = *shortData++ *ShortToFloat;
*rightInput++ = *shortData++ *ShortToFloat;
}
}
else
{
float *leftInput = _inputChannels[0];
for (var i = 0; i < numberFrames; ++i)
{
*leftInput++ = *shortData++ *ShortToFloat;
++shortData;
}
}
}
else
{
for (var i = _numInputChannels; --i >= 0;)
{
_sampleBuffer.ClearChannel(i);
}
}
_callback.AudioDeviceIOCallback(
_inputChannels, _numInputChannels,
_outputChannels, _numOutputChannels,
(int)numberFrames
);
if (_out != null)
{
byte *bytes = (byte *)_outputChannels[0];
for (var i = 0; i < numberFrames * sizeof(float); ++i)
{
_out.WriteByte(*bytes++);
}
}
{
var shortData = (short *)dataPtr.ToPointer();
float *leftOutput = _outputChannels[0];
float *rightOutput = _outputChannels[1];
if (_numOutputChannels >= 2)
{
for (var i = 0; i < numberFrames; ++i)
{
*shortData++ = (short)(*leftOutput++ *FloatToShort);
*shortData++ = (short)(*rightOutput++ *FloatToShort);
}
}
else if (_numOutputChannels == 1)
{
float *output = _outputChannels[0];
for (var i = 0; i < numberFrames; ++i)
{
short sample = (short)(*output++ *FloatToShort);
* shortData++ = sample;
* shortData++ = sample;
}
}
else
{
for (var i = 0; i < numberFrames; ++i)
{
*shortData++ = 0;
*shortData++ = 0;
}
}
}
}
else
{
var shortData = (short *)dataPtr.ToPointer();
for (var i = 0; i < numberFrames; ++i)
{
*shortData++ = 0;
*shortData++ = 0;
}
}
_clock.Stop();
return(err);
}
static AudioUnitStatus renderCallback(IntPtr inRefCon,
ref AudioUnitRenderActionFlags _ioActionFlags,
ref AudioTimeStamp _inTimeStamp,
uint _inBusNumber,
uint _inNumberFrames,
IntPtr _ioData)
{
// getting audiounit instance
var handler = GCHandle.FromIntPtr (inRefCon);
var inst = (AUGraph)handler.Target;
HashSet<RenderDelegate> renderers = inst.graphUserCallbacks;
if (renderers.Count != 0) {
using (var buffers = new AudioBuffers (_ioData)) {
foreach (RenderDelegate renderer in renderers)
renderer (_ioActionFlags, _inTimeStamp, _inBusNumber, _inNumberFrames, buffers);
return AudioUnitStatus.OK;
}
}
return AudioUnitStatus.InvalidParameter;
}
AudioUnitStatus AudioInputCallBack(AudioUnitRenderActionFlags actionFlags, AudioTimeStamp timeStamp, uint busNumber, uint numberFrames, AudioUnit audioUnit)
{
MemoryStream ms = new MemoryStream();
String s = "a000";
byte[] bufWriter = Encoding.ASCII.GetBytes(s.ToCharArray(), 0, 4);
ms.Write(bufWriter, 0, 4);
bufWriter = BitConverter.GetBytes(AudioSessionId);
if (BitConverter.IsLittleEndian)
{
Array.Reverse(bufWriter);
}
ms.Write(bufWriter, 0, 4);
long time = (long)(DateTime.UtcNow - new DateTime(1970, 1, 1)).TotalMilliseconds;
//Console.WriteLine ((time - lasttime) + " ms delay");
lasttime = time;
bufWriter = BitConverter.GetBytes(time);
if (BitConverter.IsLittleEndian)
{
Array.Reverse(bufWriter);
}
ms.Write(bufWriter, 0, 8);
var buffer = new AudioBuffer()
{
NumberChannels = 1,
DataByteSize = (int)numberFrames * 2,
Data = System.Runtime.InteropServices.Marshal.AllocHGlobal((int)numberFrames * 2)
};
var bufferList = new AudioBuffers(1);
bufferList[0] = buffer;
var status = audioUnit.Render(ref actionFlags, timeStamp, busNumber, numberFrames, bufferList);
var send = new byte[buffer.DataByteSize];
System.Runtime.InteropServices.Marshal.Copy(buffer.Data, send, 0, send.Length);
ms.Write(send, 0, send.Length);
Console.Write("\n Buffer: ");
foreach (byte b in send)
{
Console.Write("\\x" + b);
}
Console.Write("\n");
System.Runtime.InteropServices.Marshal.FreeHGlobal(buffer.Data);
byte[] sendbuf = ms.ToArray();
if (sendbuf.Length > 4096)
{
throw new Exception("Packet size too large!");
}
Task tk = Task.Factory.StartNew(() =>
{
try
{
var aSender = audioCaller.BeginSend(sendbuf, sendbuf.Length, null, null);
aSender.AsyncWaitHandle.WaitOne(TimeSpan.FromSeconds(3));
if (aSender.IsCompleted)
{
audioCaller.EndSend(aSender);
}
}
catch
{
}
});
return(AudioUnitStatus.OK);
}
public AudioUnitStatus TryRender(AudioUnitRenderActionFlags flags,
AudioTimeStamp timeStamp,
int outputBusnumber,
int numberFrames, AudioBufferList data)
{
return (AudioUnitStatus) AudioUnitRender(handle,
ref flags,
ref timeStamp,
outputBusnumber,
numberFrames,
data);
}
AudioUnitStatus AudioInputCallBack(AudioUnitRenderActionFlags actionFlags, AudioTimeStamp timeStamp, uint busNumber, uint numberFrames, AudioUnit audioUnit)
{
MemoryStream ms = new MemoryStream();
String s = "a000";
byte[] bufWriter = Encoding.ASCII.GetBytes(s.ToCharArray(), 0, 4);
ms.Write(bufWriter, 0, 4);
bufWriter = BitConverter.GetBytes(AudioSessionId);
if (BitConverter.IsLittleEndian) Array.Reverse(bufWriter);
ms.Write(bufWriter, 0, 4);
long time = (long) (DateTime.UtcNow - new DateTime(1970, 1, 1)).TotalMilliseconds;
//Console.WriteLine ((time - lasttime) + " ms delay");
lasttime = time;
bufWriter = BitConverter.GetBytes(time);
if (BitConverter.IsLittleEndian) Array.Reverse(bufWriter);
ms.Write(bufWriter, 0, 8);
var buffer = new AudioBuffer()
{
NumberChannels = 1,
DataByteSize = (int)numberFrames * 2,
Data = System.Runtime.InteropServices.Marshal.AllocHGlobal((int)numberFrames * 2)
};
var bufferList = new AudioBuffers(1);
bufferList[0] = buffer;
var status = audioUnit.Render(ref actionFlags, timeStamp, busNumber, numberFrames, bufferList);
var send = new byte[buffer.DataByteSize];
System.Runtime.InteropServices.Marshal.Copy(buffer.Data, send, 0, send.Length);
ms.Write (send, 0, send.Length);
Console.Write("\n Buffer: ");
foreach (byte b in send)
Console.Write("\\x" + b);
Console.Write("\n");
System.Runtime.InteropServices.Marshal.FreeHGlobal(buffer.Data);
byte[] sendbuf = ms.ToArray();
if (sendbuf.Length > 4096) throw new Exception("Packet size too large!");
Task tk = Task.Factory.StartNew(() =>
{
try
{
var aSender = audioCaller.BeginSend(sendbuf, sendbuf.Length, null, null);
aSender.AsyncWaitHandle.WaitOne(TimeSpan.FromSeconds(3));
if (aSender.IsCompleted) audioCaller.EndSend(aSender);
}
catch
{
}
});
return AudioUnitStatus.OK;
}
AudioUnitStatus Render (AudioUnitRenderActionFlags actionFlags, AudioTimeStamp timeStamp, uint busNumber, uint numberFrames, AudioBuffers data)
{
// Just return audio buffers from MTAudioProcessingTap.
MTAudioProcessingTapFlags flags;
CMTimeRange range;
nint n;
var error = (AudioUnitStatus)(int)audioProcessingTap.GetSourceAudio ((nint)numberFrames, data, out flags, out range, out n);
if (error != AudioUnitStatus.NoError)
Console.WriteLine ("{0} audioProcessingTap.GetSourceAudio failed", error);
return error;
}
AudioUnitStatus ConvertInputRenderCallback (AudioUnitRenderActionFlags actionFlags, AudioTimeStamp timeStamp, uint busNumber, uint numberFrames, AudioBuffers data)
{
data.SetData (0, preRenderData);
return AudioUnitStatus.NoError;
}
static int renderCallback(IntPtr inRefCon,
ref AudioUnitRenderActionFlags _ioActionFlags,
ref AudioTimeStamp _inTimeStamp,
int _inBusNumber,
int _inNumberFrames,
AudioBufferList _ioData)
{
// getting audiounit instance
var handler = GCHandle.FromIntPtr(inRefCon);
var inst = (AUGraph)handler.Target;
// invoke event handler with an argument
if (inst.RenderCallback != null){
var args = new AudioGraphEventArgs(
_ioActionFlags,
_inTimeStamp,
_inBusNumber,
_inNumberFrames,
_ioData);
inst.RenderCallback(inst, args);
}
return 0; // noerror
}
static extern AudioUnitStatus AudioUnitRender(IntPtr inUnit, ref AudioUnitRenderActionFlags ioActionFlags, ref AudioTimeStamp inTimeStamp, uint inOutputBusNumber, uint inNumberFrames, IntPtr ioData);
public AudioUnitStatus Render (ref AudioUnitRenderActionFlags actionFlags, AudioTimeStamp timeStamp, uint busNumber, uint numberFrames, AudioBuffers data)
{
return AudioUnitRender (handle, ref actionFlags, ref timeStamp, busNumber, numberFrames, (IntPtr) data);
}
static AudioUnitStatus RenderCallbackImpl (IntPtr clientData, ref AudioUnitRenderActionFlags actionFlags, ref AudioTimeStamp timeStamp, uint busNumber, uint numberFrames, IntPtr data)
{
GCHandle gch = GCHandle.FromIntPtr (clientData);
var au = (AudioUnit) gch.Target;
return au.render (actionFlags, timeStamp, busNumber, numberFrames, new AudioBuffers (data));
}
AudioUnitStatus ConvertInputRenderCallback(AudioUnitRenderActionFlags actionFlags, AudioTimeStamp timeStamp, uint busNumber, uint numberFrames, AudioBuffers data)
{
data.SetData(0, preRenderData);
return(AudioUnitStatus.NoError);
}
unsafe AudioUnitStatus HandleRenderDelegate (AudioUnitRenderActionFlags actionFlags, AudioTimeStamp timeStamp, uint busNumber, uint numberFrames, AudioBuffers data)
{
var sndbuf = soundBuffer [busNumber];
var sample = sndbuf.SampleNum; // frame number to start from
var bufSamples = sndbuf.TotalFrames; // total number of frames in the sound buffer
var input = (int*) sndbuf.Data;
var outA = (int*) data [0].Data; // output audio buffer for L channel
var outB = (int*) data [1].Data; // output audio buffer for R channel
// for demonstration purposes we've configured 2 stereo input busses for the mixer unit
// but only provide a single channel of data from each input bus when asked and silence for the other channel
// alternating as appropriate when asked to render bus 0 or bus 1's input
for (var i = 0; i < numberFrames; ++i) {
if (busNumber == 1) {
outA [i] = 0;
outB [i] = input [sample++];
} else {
outA [i] = input[sample++];
outB [i] = 0;
}
if (sample > bufSamples) {
// start over from the beginning of the data, our audio simply loops
Debug.Print ("Looping data for bus {0} after {1} source frames rendered", busNumber, sample - 1);
sample = 0;
}
}
// keep track of where we are in the source data buffer
sndbuf.SampleNum = sample;
return AudioUnitStatus.OK;
}
AudioUnitStatus _audioUnit_RenderCallback(AudioUnitRenderActionFlags actionFlags, AudioTimeStamp timeStamp, uint busNumber, uint numberFrames, AudioBuffers data)
{
// getting microphone input signal
_audioUnit.Render(ref actionFlags,
timeStamp,
1, // Remote input
numberFrames,
data);
// Getting a pointer to a buffer to be filled
IntPtr outL = data[0].Data;
IntPtr outR = data[1].Data;
// Getting signal level and trigger detection
unsafe
{
var outLPtr = (int *)outL.ToPointer();
for (int i = 0; i < numberFrames; i++)
{
// LPF
float diff = Math.Abs(*outLPtr) - _signalLevel;
if (diff > 0)
{
_signalLevel += diff / 1000f;
}
else
{
_signalLevel += diff / 10000f;
}
diff = Math.Abs(diff);
// sound triger detection
if (_triggered <= 0 && diff > _threshold)
{
_triggered = _playingDuration;
}
}
}
// playing sound
unsafe
{
var outLPtr = (int *)outL.ToPointer();
var outRPtr = (int *)outR.ToPointer();
for (int i = 0; i < numberFrames; i++)
{
_triggered = Math.Max(0, _triggered - 1);
if (_triggered <= 0)
{
// 0-filling
*outLPtr++ = 0;
*outRPtr++ = 0;
}
else
{
var buf0 = (int *)_buffer[0].Data;
var buf1 = (_numberOfChannels == 2) ? (int *)_buffer[1].Data : buf0;
if (_currentFrame >= _totalFrames)
{
_currentFrame = 0;
}
++_currentFrame;
*outLPtr++ = buf0[_currentFrame];
*outRPtr++ = buf1[_currentFrame];
}
}
}
return(AudioUnitStatus.NoError);
}
public void Render(AudioUnitRenderActionFlags flags, AudioTimeStamp timeStamp, UInt32 outputBusnumber, UInt32 numberFrames, AudioBufferList data)
{
int err = AudioUnitRender (_audioUnit,
ref flags,
ref timeStamp,
outputBusnumber,
numberFrames,
data);
if (err != 0)
throw new InvalidOperationException(String.Format("Error code:{0}", err));
}
static AudioUnitStatus RenderCallbackImpl (IntPtr clientData, ref AudioUnitRenderActionFlags actionFlags, ref AudioTimeStamp timeStamp, uint busNumber, uint numberFrames, IntPtr data)
{
GCHandle gch = GCHandle.FromIntPtr (clientData);
var au = (AUGraph) gch.Target;
RenderDelegate callback;
if (!au.nodesCallbacks.TryGetValue (busNumber, out callback))
return AudioUnitStatus.InvalidParameter;
using (var buffers = new AudioBuffers (data)) {
return callback (actionFlags, timeStamp, busNumber, numberFrames, buffers);
}
}
static extern AudioUnitStatus AudioUnitRender(IntPtr inUnit, ref AudioUnitRenderActionFlags ioActionFlags, ref AudioTimeStamp inTimeStamp,
uint inOutputBusNumber, uint inNumberFrames, IntPtr ioData);
public void Render(AudioUnitRenderActionFlags flags,
AudioTimeStamp timeStamp,
int outputBusnumber,
int numberFrames, AudioBufferList data)
{
int err = AudioUnitRender(handle,
ref flags,
ref timeStamp,
outputBusnumber,
numberFrames,
data);
if (err != 0)
throw new AudioUnitException (err);
}
public AudioUnitStatus Render(ref AudioUnitRenderActionFlags actionFlags, AudioTimeStamp timeStamp, uint busNumber, uint numberFrames, AudioBuffers data)
{
return(AudioUnitRender(handle, ref actionFlags, ref timeStamp, busNumber, numberFrames, (IntPtr)data));
}
static extern int AudioUnitRender(IntPtr inUnit, ref AudioUnitRenderActionFlags ioActionFlags, ref AudioTimeStamp inTimeStamp, int inOutputBusNumber, int inNumberFrames, AudioBufferList ioData);
AudioUnitStatus AudioInputCallBack(AudioUnitRenderActionFlags actionFlags, AudioTimeStamp timeStamp, uint busNumber, uint numberFrames, AudioUnit audioUnit)
{
var buffer = new AudioBuffer()
{
NumberChannels = 1,
DataByteSize = (int)numberFrames * 2,
Data = System.Runtime.InteropServices.Marshal.AllocHGlobal((int)numberFrames * 2)
};
var bufferList = new AudioBuffers(1);
bufferList[0] = buffer;
var status = audioUnit.Render(ref actionFlags, timeStamp, busNumber, numberFrames, bufferList);
var send = new byte[buffer.DataByteSize];
System.Runtime.InteropServices.Marshal.Copy(buffer.Data, send, 0, send.Length);
var handler = DataAvailable;
if (handler != null)
handler(this, send);
Console.Write("\n Buffer: ");
foreach (byte b in send)
Console.Write("\\x" + b);
Console.Write("\n");
System.Runtime.InteropServices.Marshal.FreeHGlobal(buffer.Data);
return AudioUnitStatus.OK;
}
AudioUnitStatus MixerRenderCallback(AudioUnitRenderActionFlags actionFlags, AudioTimeStamp timeStamp, uint busNumber, uint numberFrames, AudioBuffers data)
{
mixerRenderCallbackCount++;
return(AudioUnitStatus.NoError);
}
AudioUnitStatus ConvertInputRenderCallback (AudioUnitRenderActionFlags actionFlags, AudioTimeStamp timeStamp, uint busNumber, uint numberFrames, AudioBuffers data)
{
renderTimeStamp.SampleTime += numberFrames;
for (int channel = 0; channel < data.Count; channel++) {
data.SetData (channel, preRenderData [channel]);
}
return AudioUnitStatus.NoError;
}
AudioUnitStatus _audioUnit_RenderCallback (AudioUnitRenderActionFlags actionFlags, AudioTimeStamp timeStamp, uint busNumber, uint numberFrames, AudioBuffers data)
{
// getting microphone input signal
_audioUnit.Render (ref actionFlags,
timeStamp,
1, // Remote input
numberFrames,
data);
// Getting a pointer to a buffer to be filled
IntPtr outL = data [0].Data;
IntPtr outR = data [1].Data;
// Getting signal level and trigger detection
unsafe {
var outLPtr = (int*)outL.ToPointer ();
for (int i = 0; i < numberFrames; i++) {
// LPF
float diff = Math.Abs (*outLPtr) - _signalLevel;
if (diff > 0)
_signalLevel += diff / 1000f;
else
_signalLevel += diff / 10000f;
diff = Math.Abs (diff);
// sound triger detection
if (_triggered <= 0 && diff > _threshold) {
_triggered = _playingDuration;
}
}
}
// playing sound
unsafe {
var outLPtr = (int*)outL.ToPointer ();
var outRPtr = (int*)outR.ToPointer ();
for (int i = 0; i < numberFrames; i++) {
_triggered = Math.Max (0, _triggered - 1);
if (_triggered <= 0) {
// 0-filling
*outLPtr++ = 0;
*outRPtr++ = 0;
} else {
var buf0 = (int*)_buffer [0].Data;
var buf1 = (_numberOfChannels == 2) ? (int*)_buffer [1].Data : buf0;
if (_currentFrame >= _totalFrames) {
_currentFrame = 0;
}
++_currentFrame;
*outLPtr++ = buf0 [_currentFrame];
*outRPtr++ = buf1 [_currentFrame];
}
}
}
return AudioUnitStatus.NoError;
}
AudioUnitStatus renderDelegate(AudioUnitRenderActionFlags actionFlags, AudioTimeStamp timeStamp, uint busNumber, uint numberFrames, AudioBuffers data)
{
var err = rioUnit.Render (ref actionFlags, timeStamp, 1, numberFrames, data);
if (err != AudioUnitStatus.OK) {
return err;
}
if (FFTBufferManager == null)
return AudioUnitStatus.OK;
if (FFTBufferManager.NeedsNewAudioData) {
FFTBufferManager.GrabAudioData (data);
}
Silence (data,(int)numberFrames);
return AudioUnitStatus.OK;
}