void ProcessAudio(ProcessBuffer processingChunk)
{
if (_playbackState != PlaybackState.Playing)
{
return;
}
int bufferCount = processingChunk.AudioOut.Length;
if (bufferCount == 0)
{
return;
}
int bufferSize = processingChunk.Frames;
int floatsCount = bufferCount * bufferSize;
int bytesCount = floatsCount * sizeof(float);
byte[] fromWave = new byte[bytesCount];
_waveStream.Read(fromWave, 0, bytesCount);
float[] interlacedSamples = new float[floatsCount];
Buffer.BlockCopy(fromWave, 0, interlacedSamples, 0, bytesCount);
for (int i = 0; i < floatsCount; i++)
{
interlacedSamples [i] = interlacedSamples [i] * _volume;
}
BufferOperations.DeinterlaceAudio(interlacedSamples, processingChunk.AudioOut, bufferSize, bufferCount);
}
void PlayMidiNote(ProcessBuffer processItems)
{
foreach (MidiEventCollection <MidiInEvent> eventCollection in processItems.MidiIn)
{
Called++;
}
}
void ProcessAudio(ProcessBuffer processingChunk)
{
if (_playbackState != PlaybackState.Playing)
{
return;
}
int bufferCount = processingChunk.AudioOut.Length;
if (bufferCount == 0)
{
return;
}
int bufferSize = processingChunk.Frames;
int floatsCount = bufferCount * bufferSize;
float[] interlacedSamples = new float[floatsCount];
_sampleSource.Read(interlacedSamples, 0, floatsCount);
for (int i = 0; i < floatsCount; i++)
{
interlacedSamples [i] = interlacedSamples [i] * _volume;
}
BufferOperations.DeinterlaceAudio(interlacedSamples, processingChunk.AudioOut, bufferSize, bufferCount);
}
void CopyInToOut(ProcessBuffer processItems)
{
for (int i = 0; i < Math.Min(processItems.AudioIn.Length, processItems.AudioOut.Length); i++)
{
Array.Copy(processItems.AudioIn [i].Audio, processItems.AudioOut [i].Audio, processItems.AudioIn [i].BufferSize);
}
Called++;
}
void AnalyseOut(ProcessBuffer processItem)
{
foreach (AudioBuffer outBuffer in processItem.AudioOut)
{
if (outBuffer.Audio.Any(s => s != 0))
{
NotEmptySamples++;
}
}
}
public byte[] OutPutSocketBytes()
{
byte[] receivedData;
lock (ProcessBuffer)
{
receivedData = ProcessBuffer.ToArray();
for (var i = 0; i < receivedData.Length; i++)
{
ProcessBuffer.RemoveAt(0);
}
}
return(receivedData);
}
void ProcessAudio(ProcessBuffer processingChunk)
{
int bufferCount = processingChunk.AudioIn.Length;
if (bufferCount == 0)
{
return;
}
int bufferSize = processingChunk.AudioIn [0].BufferSize;
int floatsCount = bufferCount * bufferSize;
int bytesCount = floatsCount * sizeof(float);
float[] interlacedSamples = BufferOperations.InterlaceAudio(processingChunk.AudioIn, bufferSize, bufferCount);
byte[] waveInData = new byte[bytesCount];
Buffer.BlockCopy(interlacedSamples, 0, waveInData, 0, bytesCount);
if (DataAvailable != null)
{
DataAvailable(this, new WaveInEventArgs(waveInData, bytesCount));
}
}
private static long BayerMooreScanForPattern(Process proc, uint[] p, IntPtr baseAddr, long size)
{
Pattern <uint> pattern = new Pattern <uint>(p);
long ti = 0; //text index
int pi = (pattern.Length - 1); //pattern index
int patternSize = pattern.Length * sizeof(uint);
ProcessBuffer buffer = new ProcessBuffer();
//buffer.Initialize(proc, baseAddr);
while (ti + patternSize <= size)
{
long readIndex = pi * sizeof(uint) + ti;
uint tV = //(uint)ReadProcessInt32(proc, baseAddr + readIndex, out int r);
(uint)buffer.ReadInt32(proc, (IntPtr)((long)baseAddr + readIndex));
if (tV == pattern.Data[pi])
{
pi--;
if (pi < 0)
{
return(ti);
}
continue;
}
//pattern doesn't match
int shift = pattern.GetShift(tV, pi);
if (shift < 0)
{
ti += pattern.Length * sizeof(uint);
}
else
{
ti += (pi - shift) * sizeof(uint);
}
pi = (pattern.Length - 1);
}
return(-1);
}
public void SequenceMidi(ProcessBuffer processItems)
{
foreach (MidiEventCollection <MidiOutEvent> eventCollection in processItems.MidiOut)
{
var noteOn = new MidiOutEvent(processItems.Frames / 4,
new byte[] {
0x90 /* note on */,
30 /* note */,
64 /* velocity */
});
var noteOff = new MidiOutEvent(processItems.Frames / 2,
new byte[] {
0x80 /* note off */,
30 /* note */,
64 /* velocity */
});
eventCollection.AddEvent(noteOn);
eventCollection.AddEvent(noteOff);
Called++;
}
}
public ProcessBufferShould()
{
_sut = new ProcessBuffer <double>();
_fixture = new Fixture();
_buffer = _fixture.Create <Buffer <double> >();
}
void CallBackTwo(ProcessBuffer processItems)
{
Called |= 2;
}
void CallBackOne(ProcessBuffer processItems)
{
Called |= 1;
}
void ChannelCounter(ProcessBuffer processItems)
{
Called = processItems.AudioIn.Length;
}
public IGenericProcess GetGenericProcess(ProcessType processType)
{
IGenericProcess genericProcess = null;
switch (processType)
{
case ProcessType.Buffer:
genericProcess = new ProcessBuffer();
break;
case ProcessType.CircularBuffer:
genericProcess = new ProcessCircularBuffer();
break;
case ProcessType.Array:
genericProcess = new ProcessArray();
break;
case ProcessType.List:
genericProcess = new ProcessList();
break;
case ProcessType.Queue:
genericProcess = new ProcessQueue();
break;
case ProcessType.Stack:
genericProcess = new ProcessStack();
break;
case ProcessType.HashSet:
genericProcess = new ProcessHashSet();
break;
case ProcessType.LinkedList:
genericProcess = new ProcessLinkedList();
break;
case ProcessType.Dictionary:
genericProcess = new ProcessDictionary();
break;
case ProcessType.Sort:
genericProcess = new ProcessSort();
break;
case ProcessType.ComparingEmployees:
genericProcess = new ProcessComparingEmployees();
break;
case ProcessType.Delegates:
genericProcess = new ProcessDelegates();
break;
case ProcessType.Constraints:
genericProcess = new ProcessConstraints();
break;
case ProcessType.GenericMethods:
genericProcess = new ProcessGenericMethods();
break;
case ProcessType.IocContainer:
genericProcess = new ProcessIocContainer();
break;
case ProcessType.GenericEnum:
genericProcess = new ProcessGenericEnum();
break;
case ProcessType.BaseTypes:
genericProcess = new ProcessBaseTypes();
break;
case ProcessType.GenericStatics:
genericProcess = new ProcessGenericStatics();
break;
default:
break;
}
return(genericProcess);
}