private void OpenWaveFileThread()
{
CreateOptimizedArray();
mDrawWave = true;
WaveFormat fmt = mDrawSource.WaveFormat;
mRawDrawReader = new FileStream(mRawFileName, FileMode.Open, FileAccess.Read);
mDrawSource = new RawDataReader(mRawDrawReader, fmt).ToSampleSource();
SamplesPerPixel = (int)(mDrawSource.Length / CWidth);
mRawPlayReader = new FileStream(mRawFileName, FileMode.Open, FileAccess.Read);
mPlaySource = new RawDataReader(mRawPlayReader, fmt).ToSampleSource();
PeakMeter peakMeter = new PeakMeter(mPlaySource)
{
Interval = 50
};
peakMeter.PeakCalculated += PeakMeter_PeakCalculated;
mWaveSource = peakMeter.ToWaveSource(16);
mMusicPlayer.Open(mWaveSource, mDevice);
InvokeOnUiThreadIfRequired(() => {
progress.Value = 0;
cursorTimer.Enabled = true;
playTimer.Enabled = true;
hrScroll.Enabled = true;
Refresh();
});
}
static void Main(string[] args)
{
if (args.Length < 0)
{
return;
}
PeakMeter peakMeter1 = new PeakMeter();
Amplifier amplifier = new Amplifier(AudioTools.dBFSToLinearf(12f));
PeakLimiter limiter = new PeakLimiter(20, 20, AudioTools.dBFSToLinearf(-3.0f));
PeakMeter peakMeter2 = new PeakMeter();
FilterChain filterChain = new FilterChain();
filterChain.Filters.Add(peakMeter1);
filterChain.Filters.Add(amplifier);
filterChain.Filters.Add(limiter);
filterChain.Filters.Add(peakMeter2);
WaveFileReader waveFileReader = new WaveFileReader(args[0]);
waveFileReader.Position = 0;
byte[] byteBuffer = new byte[10 * 1024];
float [] floatBuffer = null;
int bytesRead = 0, samplesAvailable = 0;
filterChain.Init(waveFileReader.WaveFormat.SampleRate, waveFileReader.WaveFormat.Channels);
int processed = 0;
while (true)
{
bytesRead = waveFileReader.Read(byteBuffer, 0, 10 * 1024);
if (bytesRead == 0)
{
break;
}
AudioBufferConverter.ConvertByteArrayToFloatArray(byteBuffer, bytesRead, waveFileReader.WaveFormat.BitsPerSample, ref floatBuffer, ref samplesAvailable);
filterChain.ProcessFrames(floatBuffer, samplesAvailable);
processed += bytesRead;
}
System.Console.WriteLine("processed: " + processed);
System.Console.WriteLine("peak1: " + peakMeter1.GlobalPeakSinceStartdBFS);
System.Console.WriteLine("peak2: " + peakMeter2.GlobalPeakSinceStartdBFS);
System.Console.ReadKey();
}
private void RenderPeakMeter(Sample Sample)
{
Dispatcher.BeginInvoke(() =>
{
try
{
int barSpacing = 25;
int barWidth = (barSpacing - 8);
int lineWidth = (barWidth + 1);
int leftOffset = 60;
byte[] frequencyPeaks = PeakMeter.CalculateFrequencies(Sample.Spectrogram, 44100);
if (!(_clearEffectIsEnabled))
{
ClearOutputBitmap();
}
int baseY = 255;
int offsetX = 0;
int offsetY = 0;
for (int x = 0; x < frequencyPeaks.Length; x++)
{
offsetX = (x * barSpacing) + leftOffset;
offsetY = (baseY - frequencyPeaks[x]);
_lastPeaks[x] = CalculatePeakDelay(_lastPeaks[x], offsetY, 2, baseY);
_maximumPeaks[x] = CalculatePeakDelay(_maximumPeaks[x], offsetY, 1, baseY);
_outputWriteableBitmap.FillRectangle(offsetX, _lastPeaks[x], (offsetX + barWidth), baseY, _primaryColour);
// Only draw the maximum peak if it is above the empty bar level (cutoff)
if (_lastPeaks[x] < baseY)
{
_outputWriteableBitmap.DrawLine(offsetX, _maximumPeaks[x], (offsetX + lineWidth), _maximumPeaks[x], _secondaryColour);
}
}
if (_clearEffectIsEnabled)
{
RunClearEffect();
}
FlushOutputBitmap();
}
catch
{ }
});
}
public void Open(string filename, MMDevice device)
{
CleanupPlayback();
_peakMeter = CodecFactory.Instance.GetCodec(filename)
.ToSampleSource()
.AppendSource(Equalizer.Create10BandEqualizer, out _equalizer)
.ToMono()
.AppendSource(src => new PeakMeter(src));
_pitchShifter = _peakMeter
.AppendSource(src => new PitchShifter(src));
_sampleSource = _pitchShifter
.AppendSource(x => new BiQuadFilterSource(x));
_soundOut = new WasapiOut()
{
Latency = 100, Device = device
};
_soundOut.Initialize(_sampleSource.ToWaveSource());
if (PlaybackStopped != null)
{
_soundOut.Stopped += PlaybackStopped;
}
}
protected override void GetSampleAsync(MediaStreamType mediaStreamType)
{
try
{
_logger.LogSampleRequested();
var resetEvents = new AutoResetEvent[AudioControllers.Count];
// Dequeue the sample from the media controllers, so that each controller's entire audio stack gets exercised.
for (int i = 0; i < AudioControllers.Count; i++)
{
var audioControllerEntry = AudioControllers[i];
resetEvents[i] = audioControllerEntry.ResetEvent;
// Throw the decoding work into a thread pool.
ThreadPool.QueueUserWorkItem(obj =>
{
var entry = (AudioControllerEntry)obj;
entry.MediaController.GetNextAudioFrame(ms =>
{
try
{
entry.LastMemoryStream = ms;
// Check to see if the frame has the expected frequency, and if not, update a counter.
if (!UseGeneratedTone)
{
return;
}
if (entry.WriteToBuffer(entry.LastMemoryStream))
{
entry.Clear();
byte[] frequencies = PeakMeter.CalculateFrequencies(entry.SampleBuffer, AudioFormat.Default.SamplesPerSecond);
bool frequencyMismatch = false;
if (frequencies[_frequencyIndex] == 0)
{
frequencyMismatch = true;
}
else
{
if (frequencies.Where((t, j) => j != _frequencyIndex && t > frequencies[_frequencyIndex]).Any())
{
frequencyMismatch = true;
}
}
entry.LogFrequencyCounterMismatch(frequencyMismatch);
}
}
catch (Exception ex)
{
ClientLogger.Debug(ex.ToString);
}
finally
{
entry.ResetEvent.Set();
}
});
}, audioControllerEntry);
}
// Wait for all the decoding jobs to finish
WaitHandle.WaitAll(resetEvents);
// Submit only the first sample retrieved to be played.
var rawSample = AudioControllers[0].LastMemoryStream;
var sample = new MediaStreamSample(
_mediaStreamDescription,
rawSample,
0,
rawSample.Length,
(DateTime.Now - _startTime).Ticks,
_emptySampleDict);
ReportGetSampleCompleted(sample);
}
catch (Exception ex)
{
ClientLogger.Debug(ex.ToString());
}
}
public bool StartCapture(Action <byte[]> data)
{
var inputBufferSize = aac_enc.GetInputBufferSize();
var outputBufferMaxSize = aac_enc.GetMaxOutputBufferSize();
if (inputBufferSize <= 0 || outputBufferMaxSize <= 0)
{
return(false);
}
var inputBuffer = new byte[inputBufferSize];
var outputBuffer = new byte[outputBufferMaxSize];
var outputPtr = InteropHelper.AllocByteArray(outputBuffer);
var soundInSource = new SoundInSource(_waveIn);
var peakMeter = new PeakMeter(soundInSource.ToSampleSource());
_finalSource = peakMeter.ToWaveSource(BitPerSample);
soundInSource.DataAvailable += (s, e) =>
{
try
{
int read;
while ((read = _finalSource.Read(inputBuffer, 0, inputBufferSize)) > 0)
{
var inputPtr = InteropHelper.AllocByteArray(inputBuffer);
var size = aac_enc.EncodeBuffer(inputPtr, read, outputPtr, outputBufferMaxSize);
InteropHelper.FreeObjectArray(inputPtr, typeof(byte), inputBufferSize);
if (size > 0)
{
byte[] result;
if (InteropHelper.ParsePtrToByteArray(outputPtr, size, out result))
{
data.Invoke(result);
}
}
}
}
catch (Exception ex)
{
}
};
peakMeter.PeakCalculated += PeakMeterOnPeakCalculated;
try
{
_waveIn.Start();
}
catch (MmException ex)
{
peakMeter.PeakCalculated -= PeakMeterOnPeakCalculated;
return(false);
}
_canStop = true;
return(true);
}
private void RenderFFTScan(Sample Sample)
{
Dispatcher.BeginInvoke(() =>
{
try
{
int height = (int)_outputWriteableBitmap.PixelHeight;
int width = (int)_outputWriteableBitmap.PixelWidth;
byte[] frequencyPeaks = PeakMeter.CalculateFrequencies(Sample.Spectrogram, 44100);
if (_fftScanIsCleared)
{
ClearOutputBitmap();
_xRunningScanCounter = _marginLeft;
_fftScanIsCleared = false;
}
int offsetY = 0;
int baseOffsetY = 0;
int maximumPeak = 0;
int bandTotal = frequencyPeaks.Length;
int drawingColour = _primaryColour;
bool isAlternateColour = false;
// Clear previous scan line
_outputWriteableBitmap.DrawLine(_xRunningScanCounter, 0, _xRunningScanCounter, height, _clearColour);
for (int x = 0; x < bandTotal; x++)
{
maximumPeak = (frequencyPeaks[x] >> 1);
baseOffsetY = ((bandTotal - x) * 39);
_maximumPeaks[x] = ((_maximumPeaks[x] + maximumPeak) >> 1);
offsetY = (baseOffsetY - _maximumPeaks[x]);
if (isAlternateColour)
{
drawingColour = _alternatePrimaryColour;
}
else
{
drawingColour = _primaryColour;
}
isAlternateColour = !(isAlternateColour);
if (offsetY == baseOffsetY)
{
_outputWriteableBitmap.SetPixel(_xRunningScanCounter, baseOffsetY, drawingColour);
}
else
{
_outputWriteableBitmap.DrawLine(_xRunningScanCounter, offsetY, _xRunningScanCounter, baseOffsetY, drawingColour);
}
}
// Current Scanline
_outputWriteableBitmap.DrawLine((_xRunningScanCounter + 1), 0, (_xRunningScanCounter + 1), height, _secondaryColour);
_xRunningScanCounter++;
if (_xRunningScanCounter >= _widthWithoutMarginRight)
{
_outputWriteableBitmap.DrawLine(_xRunningScanCounter, 0, _xRunningScanCounter, height, _clearColour);
_xRunningScanCounter = _marginLeft;
}
FlushOutputBitmap();
}
catch
{
}
});
}
