public int Read(float[] buffer, int offset, int count)
{
int outputSamples = 0;
this.sourceBuffer = BufferHelpers.Ensure(this.sourceBuffer, count);
lock (sources) {
//cycle through each input source, backwards
for (int sourceindex = sources.Count - 1; sourceindex >= 0; sourceindex += -1) {
if (sources(sourceindex).hasData) {
int samplesRead = sources(sourceindex).Read(this.sourceBuffer, 0, count);
int outIndex = offset;
for (int inIndex = 0; inIndex <= samplesRead - 2; inIndex += 2) {
if (inIndex >= outputSamples) {
buffer(outIndex) = this.sourceBuffer(inIndex) * MasterVolFac;
buffer(outIndex + 1) = this.sourceBuffer(inIndex + 1) * MasterVolFac;
} else {
buffer(outIndex) += this.sourceBuffer(inIndex) * MasterVolFac;
buffer(outIndex + 1) += this.sourceBuffer(inIndex + 1) * MasterVolFac;
}
//******************* for metering display
if (ShowOutputMeters) {
for (int chno = 0; chno <= channels - 1; chno++) {
thissampleValue = Math.Abs(buffer(offset + inIndex + chno));
maxSamples(chno) = Math.Max(maxSamples(chno), thissampleValue);
sampleCount += 1;
if (sampleCount >= SamplesPerNotification) {
if (StreamVolume != null) {
StreamVolume(this, args);
}
sampleCount = 0;
Array.Clear(maxSamples, 0, channels);
}
}
}
//******************
outIndex += 2;
}
outputSamples = Math.Max(samplesRead, outputSamples);
}
}
}
return outputSamples;
} public static void TrimMp3File(string inputPath, string outputPath, TimeSpan? begin, TimeSpan? end)
{
// This routine trims an MP3 file
// Ref: http://stackoverflow.com/questions/7932951/trimming-mp3-files-using-naudio
// original code from Mark Heath (Naudio creator)
// ********************** DEBUG: Start *************************
TimeSpan Zero = new TimeSpan(0,0,0);
TimeSpan CurrentTime;
TimeSpan CalculatedCurrentTime, CalculatedCurrentTimeBasedOnBytesRead;
bool ProbePoint;
long BytesRead = 0;
// ********************** DEBUG: End *************************
if (begin.HasValue && end.HasValue && begin > end)
throw new ArgumentOutOfRangeException("end", "end should be greater than begin");
using (var reader = new Mp3FileReader(inputPath))
{
using (var writer = File.Create(outputPath))
{
Mp3Frame frame;
while ((frame = reader.ReadNextFrame()) != null)
{
// ********************** DEBUG: Start **************************
// BUG: reader.Position and reader.CurrentTime are never updated
// **************************************************************
CurrentTime = reader.CurrentTime;
CalculatedCurrentTime = TimeSpan.FromSeconds((double)reader.Position / reader.WaveFormat.AverageBytesPerSecond);
BytesRead += frame.RawData.Length;
CalculatedCurrentTimeBasedOnBytesRead = TimeSpan.FromSeconds((double)BytesRead / reader.WaveFormat.AverageBytesPerSecond); ;
if (CurrentTime != Zero)
{
ProbePoint = true ;
}
// ********************** DEBUG: End *************************
if (reader.CurrentTime >= begin || !begin.HasValue)
{
if (reader.CurrentTime <= end || !end.HasValue)
writer.Write(frame.RawData, 0, frame.RawData.Length);
else break;
}
}
}
}
}As a work around, I altered the program to calculate it's own CurrentTime rather than relying on reader.CurrentTime as follows.
I'm back in business ...
public static void TrimMp3File(string inputPath, string outputPath, TimeSpan? begin, TimeSpan? end)
{
// This routine trims an MP3 file
// Ref: http://stackoverflow.com/questions/7932951/trimming-mp3-files-using-naudio
// * original code from Mark Heath (Naudio creator)
// http://stackoverflow.com/questions/6220660/calculating-the-length-of-mp3-frames-in-milliseconds
// * frame length in ms formula: lucianolev
double currentSecond = 0.0D; // 2016-11-26: Start - fix: replaced reliance on reader.CurrentTime (which is not being updated)
double beginSecond = 0.0D; // with the calculated currentSecond.
double endSecond = 9999.0D;
TimeSpan totalDuration = new TimeSpan(0, 0, 0); // 2016-11-26: End
if (begin.HasValue && end.HasValue && begin > end)
throw new ArgumentOutOfRangeException("end", "end should be greater than begin");
using (var reader = new Mp3FileReader(inputPath)) {
totalDuration = reader.TotalTime; // 2016-11-26: Start
if (begin.HasValue) beginSecond = ((TimeSpan)begin).TotalSeconds;
if (end.HasValue) endSecond = ((TimeSpan)end).TotalSeconds;
else endSecond = totalDuration.TotalSeconds; // 2016-11-26: End
using (var writer = File.Create(outputPath)) {
Mp3Frame frame;
while ((frame = reader.ReadNextFrame()) != null) {
currentSecond += ((double)frame.SampleCount / (double)frame.SampleRate); // 2016-11-26
if (currentSecond >= beginSecond) { // 2016-11-26
if (currentSecond <= endSecond) // 2016-11-26
writer.Write(frame.RawData, 0, frame.RawData.Length);
else break;
}
}
}
}
}var outFormat = new WaveFormat(32000, 16, 1);
int bps = (int)inStream.WaveFormat.AverageBytesPerSecond;
float diff = (int)outFormat.AverageBytesPerSecond;
diff /= bps;
using (var Resampler = new MediaFoundationResampler(inStream, outFormat))
{
bytes = new byte[(int)(inStream.Length * diff)];
Resampler.Read(bytes, 0, (int)bytes.Length);
}WasapiOutRT _wavePlayer;
BufferedWaveProvider _bufferProvider;
public Audio()
{
_wavePlayer = new WasapiOutRT(NAudio.CoreAudioApi.AudioClientShareMode.Shared, 100);
_wavePlayer.Init(() =>
{
WaveFormat waveFormat = new WaveFormat(SAMPLE_RATE, 16, 2);
_bufferProvider = new BufferedWaveProvider(waveFormat);
_bufferProvider.DiscardOnBufferOverflow = true;
return _bufferProvider;
});
}
public bool TrySubmitBuffer(byte[] buffer, int buffer_size)
{
if (buffer_size >= SUBMIT_SIZE)
{
if (_wavePlayer.PlaybackState == PlaybackState.Stopped)
{
_wavePlayer.Play();
}
else
{
_bufferProvider.AddSamples(buffer, 0, buffer_size);
}
return true;
}
return false;
}