private static IList <PeakInfo> GetInfo(IPeakProvider peakProvider, PeakProviderSettings settings)
{
var infos = new List <PeakInfo>();
int x = 0;
var currentPeak = peakProvider.GetNextPeak();
while (x < settings.Width)
{
var nextPeak = peakProvider.GetNextPeak();
for (int n = 0; n < settings.PixelsPerPeak; n++)
{
x++;
}
for (int n = 0; n < settings.SpacerPixels; n++)
{
// spacer bars are always the lower of the
var max = Math.Min(currentPeak.Max, nextPeak.Max);
var min = Math.Max(currentPeak.Min, nextPeak.Min);
x++;
}
infos.Add(currentPeak);
currentPeak = nextPeak;
}
infos.Where(x => x.Max > 0);
return(infos);
}
private void RenderThreadFunc(IPeakProvider peakProvider, WaveFormRendererSettings settings)
{
try
{
System.Drawing.Image image = _waveFormRenderer.Render(SoundItemData.FullPath, peakProvider, settings);
Dispatcher.Invoke(() =>
{
MemoryStream stream = new MemoryStream();
image.Save(stream, ImageFormat.Png);
SoundItemData.Image = new BitmapImage();
SoundItemData.Image.BeginInit();
SoundItemData.Image.StreamSource = stream;
SoundItemData.Image.EndInit();
SoundWave.Stretch = Stretch.Fill;
SoundWave.Source = SoundItemData.Image;
});
}
catch (Exception e)
{
int i = 0;
i++;
}
}
private static Image Render(IPeakProvider peakProvider, WaveFormRendererSettings settings)
{
if (settings.DecibelScale)
{
peakProvider = new DecibelPeakProvider(peakProvider, 48);
}
var b = new Bitmap(settings.Width, settings.TopHeight + settings.BottomHeight);
if (settings.BackgroundColor == Color.Transparent)
{
b.MakeTransparent();
}
using (var g = Graphics.FromImage(b))
using (var backgroundBrush = settings.BackgroundBrush.Clone() as Brush)
using (var topPeakPen = settings.TopPeakPen.Clone() as Pen)
using (var bottomPeakPen = settings.BottomPeakPen.Clone() as Pen)
//using (var topSpacerPen = settings.TopSpacerPen.Clone() as Pen)
//using (var bottomSpacerPen = settings.BottomSpacerPen.Clone() as Pen)
{
g.FillRectangle(backgroundBrush, 0, 0, b.Width, b.Height);
var midPoint = settings.TopHeight;
var x = 0;
var currentPeak = peakProvider.GetNextPeak();
while (x < settings.Width)
{
var nextPeak = peakProvider.GetNextPeak();
for (var n = 0; n < settings.PixelsPerPeak; n++)
{
var lineHeight = settings.TopHeight * currentPeak.Max;
g.DrawLine(topPeakPen, x, midPoint, x, midPoint - lineHeight);
lineHeight = settings.BottomHeight * currentPeak.Min;
g.DrawLine(bottomPeakPen, x, midPoint, x, midPoint - lineHeight);
x++;
}
for (var n = 0; n < settings.SpacerPixels; n++)
{
// spacer bars are always the lower of the
var max = Math.Min(currentPeak.Max, nextPeak.Max);
var min = Math.Max(currentPeak.Min, nextPeak.Min);
var lineHeight = settings.TopHeight * max;
g.DrawLine(settings.TopSpacerPen, x, midPoint, x, midPoint - lineHeight);
lineHeight = settings.BottomHeight * min;
g.DrawLine(settings.BottomSpacerPen, x, midPoint, x, midPoint - lineHeight);
x++;
}
currentPeak = nextPeak;
}
}
return(b);
}
public PeakInfo[] getSampleArray(IPeakProvider peakProvider, int sampleCount)
{
PeakInfo[] samples = new PeakInfo[sampleCount];
for (int i = 0; i < sampleCount; i++)
{
samples[i] = peakProvider.GetNextPeak();
}
return(samples);
}
public Image Render(WaveStream sampleProvider, IPeakProvider peakProvider, WaveFormRendererSettings settings)
{
int bytesPerSample = (sampleProvider.WaveFormat.BitsPerSample / 8);
var samples = sampleProvider.Length / (bytesPerSample);
var samplesPerPixel = (int)(samples / settings.Width);
var stepSize = settings.PixelsPerPeak + settings.SpacerPixels;
peakProvider.Init((ISampleProvider)sampleProvider, samplesPerPixel * stepSize);
return(Render(peakProvider, settings));
}
public Image Render(string selectedFile, IPeakProvider peakProvider, WaveFormRendererSettings settings)
{
using (var reader = new AudioFileReader(selectedFile))
{
var bytesPerSample = reader.WaveFormat.BitsPerSample / 8;
var samples = reader.Length / bytesPerSample;
var samplesPerPixel = (int)(samples / settings.Width);
var stepSize = settings.PixelsPerPeak + settings.SpacerPixels;
peakProvider.Init(reader, samplesPerPixel * stepSize);
return(Render(peakProvider, settings));
}
}
public ICanvasImage Render(string selectedFile, IPeakProvider peakProvider, WaveFormRendererSettings settings)
{
using (var reader = new MediaFoundationReader(selectedFile))
{
int bytesPerSample = (reader.WaveFormat.BitsPerSample / 8);
var samples = reader.Length / (bytesPerSample);
var samplesPerPixel = (int)(samples / settings.Width);
var stepSize = settings.PixelsPerPeak + settings.SpacerPixels;
peakProvider.Init(reader.ToSampleProvider(), samplesPerPixel * stepSize);
return(Render(peakProvider, settings));
}
}
/// <summary>
///
/// </summary>
/// <param name="selectedFile"></param>
/// <param name="peakProvider"></param>
/// <param name="settings"></param>
/// <param name="audioFileReader">Like AudioFileReader, it has to inherit both WaveStream and ISampleProvider</param>
/// <returns></returns>
public Image Render(string selectedFile, IPeakProvider peakProvider, WaveFormRendererSettings settings, Func <string, WaveStream> audioFileReader)
{
using (WaveStream reader = audioFileReader.Invoke(selectedFile))
{
int bytesPerSample = (reader.WaveFormat.BitsPerSample / 8);
var samples = reader.Length / (bytesPerSample);
var samplesPerPixel = (int)(samples / settings.Width);
var stepSize = settings.PixelsPerPeak + settings.SpacerPixels;
peakProvider.Init((ISampleProvider)reader, samplesPerPixel * stepSize);
return(Render(peakProvider, settings));
}
}
private static Image Render(IPeakProvider peakProvider, WaveFormRendererSettings settings)
{
Log.Information(rrender + "Render started");
if (settings.DecibelScale)
{
peakProvider = new DecibelPeakProvider(peakProvider, 48);
}
var b = new Bitmap(settings.Width, settings.TopHeight + settings.BottomHeight);
if (settings.BackgroundColor == Color.Transparent)
{
b.MakeTransparent();
}
using (var g = Graphics.FromImage(b))
{
g.FillRectangle(settings.BackgroundBrush, 0, 0, b.Width, b.Height);
var midPoint = settings.TopHeight;
int x = 0;
var currentPeak = peakProvider.GetNextPeak();
while (x < settings.Width)
{
var nextPeak = peakProvider.GetNextPeak();
//for (int n = 0; n < settings.PixelsPerPeak; n++)
//{
var lineHeight = settings.TopHeight * currentPeak.Max;
g.DrawLine(settings.TopPeakPen, x, midPoint, x, midPoint - lineHeight);
lineHeight = settings.BottomHeight * currentPeak.Min;
g.DrawLine(settings.BottomPeakPen, x, midPoint, x, midPoint - lineHeight);
x++;
//}
/*for (int n = 0; n < settings.SpacerPixels; n++)
* {
* // spacer bars are always the lower of the
* var max = Math.Min(currentPeak.Max, nextPeak.Max);
* var min = Math.Max(currentPeak.Min, nextPeak.Min);
*
* var lineHeight = settings.TopHeight * max;
* g.DrawLine(settings.TopSpacerPen, x, midPoint, x, midPoint - lineHeight);
* lineHeight = settings.BottomHeight * min;
* g.DrawLine(settings.BottomSpacerPen, x, midPoint, x, midPoint - lineHeight);
* x++;
* }*/
currentPeak = nextPeak;
}
}
Log.Information(rrender + "Render finished");
return(b);
}
private static ICanvasImage Render(IPeakProvider peakProvider, WaveFormRendererSettings settings)
{
if (settings.DecibelScale)
{
peakProvider = new DecibelPeakProvider(peakProvider, 48);
}
var b = new CanvasRenderTarget(settings.Device, settings.Width, settings.TopHeight + settings.BottomHeight, 96);
using (var ds = b.CreateDrawingSession())
{
if (settings.BackgroundColor == Colors.Transparent)
{
ds.Clear(Colors.Transparent);
}
ds.FillRectangle(0, 0, (float)b.Bounds.Width, (float)b.Bounds.Height, settings.BackgroundBrush);
var midPoint = settings.TopHeight;
int x = 0;
var currentPeak = peakProvider.GetNextPeak();
while (x < settings.Width)
{
var nextPeak = peakProvider.GetNextPeak();
for (int n = 0; n < settings.PixelsPerPeak; n++)
{
var lineHeight = settings.TopHeight * currentPeak.Max;
ds.DrawPen(settings.TopPeakPen, x, midPoint, x, midPoint - lineHeight);
lineHeight = settings.BottomHeight * currentPeak.Min;
ds.DrawPen(settings.BottomPeakPen, x, midPoint, x, midPoint - lineHeight);
x++;
}
for (int n = 0; n < settings.SpacerPixels; n++)
{
// spacer bars are always the lower of the
var max = Math.Min(currentPeak.Max, nextPeak.Max);
var min = Math.Max(currentPeak.Min, nextPeak.Min);
var lineHeight = settings.TopHeight * max;
ds.DrawPen(settings.TopSpacerPen, x, midPoint, x, midPoint - lineHeight);
lineHeight = settings.BottomHeight * min;
ds.DrawPen(settings.BottomSpacerPen, x, midPoint, x, midPoint - lineHeight);
x++;
}
currentPeak = nextPeak;
}
}
return(b);
}
private void RenderThreadFunc(IPeakProvider peakProvider, WaveFormRendererSettings settings)
{
System.Drawing.Image image = null;
try
{
image = waveFormRenderer.Render(selectedFile, peakProvider, settings);
hello.Source = helperext.ToWpfImage(image);
}
catch (Exception e)
{
MessageBox.Show(e.Message);
}
}
private static Image Render(string selectedFile, IPeakProvider peakProvider, WaveRendererSettings settings)
{
using (var reader = new AudioFileReader(selectedFile))
{
settings.Width = settings.Width ?? (int)reader.TotalTime.TotalMilliseconds / 2;
int bytesPerSample = (reader.WaveFormat.BitsPerSample / 8);
var samples = reader.Length / (bytesPerSample);
var samplesPerPixel = (int)(samples / settings.Width);
var stepSize = settings.PixelsPerPeak + settings.SpacerPixels;
peakProvider.Init(reader, samplesPerPixel * stepSize);
return(Render(peakProvider, settings));
}
}
private void RenderThreadFunc(IPeakProvider peakProvider, WaveFormRendererSettings settings)
{
Image image = null;
try {
image = waveFormRenderer.Render(fileName, peakProvider, settings);
}
catch (Exception e) {
MessageBox.Show("error");
MessageBox.Show(e.Message);
}
BeginInvoke((Action)(() => FinishedRender(image)));
}
public Image Render(string selectedFile, IPeakProvider peakProvider, WaveFormRendererSettings settings, CancellationToken?ct = null)
{
ct?.ThrowIfCancellationRequested();
using (var reader = new AudioFileReader(selectedFile))
{
int bytesPerSample = (reader.WaveFormat.BitsPerSample / 8);
var samples = reader.Length / (bytesPerSample);
var samplesPerPixel = (int)(samples / settings.Width);
var stepSize = settings.PixelsPerPeak + settings.SpacerPixels;
ct?.ThrowIfCancellationRequested();
peakProvider.Init(reader, samplesPerPixel * stepSize);
return(Render(peakProvider, settings, ct));
}
}
private void RenderThreadFunc(IPeakProvider peakProvider, WaveFormRendererSettings settings)
{
Image image = null;
try
{
image = waveFormRenderer.Render(selectedFile, peakProvider, settings);
}
catch (Exception e)
{
MessageBox.Show(e.Message);
}
FinishedRender(image);
}
public async Task <ICanvasImage> RenderAsync(StorageFile selectedFile, IPeakProvider peakProvider, WaveFormRendererSettings settings)
{
var randomAcessStream = await selectedFile.OpenReadAsync();
using (var reader = new StreamMediaFoundationReader(randomAcessStream.AsStream()))
{
int bytesPerSample = (reader.WaveFormat.BitsPerSample / 8);
var samples = reader.Length / (bytesPerSample);
var samplesPerPixel = (int)(samples / settings.Width);
var stepSize = settings.PixelsPerPeak + settings.SpacerPixels;
peakProvider.Init(reader.ToSampleProvider(), samplesPerPixel * stepSize);
return(Render(peakProvider, settings));
}
}
private void RenderThread(IPeakProvider peak, WaveFormRendererSettings settings)
{
Image image = null;
try
{
image = waveFormRenderer.Render(path, peak, settings);
}
catch (Exception e)
{
MessageBox.Show(e.Message);
}
BeginInvoke((Action)(() => PctbxWave.Image = image));
}
private static IList <PeakInfo> GetInfo(IPeakProvider peakProvider, string selectedFile, int pointOnXAccess)
{
var settings = new PeakProviderSettings();
using (var reader = new AudioFileReader(selectedFile))
{
int bytesPerSample = (reader.WaveFormat.BitsPerSample / 8);
settings.Width = pointOnXAccess;
var samples = reader.Length / (bytesPerSample);
var samplesPerPixel = (int)(samples / settings.Width);
var stepSize = settings.PixelsPerPeak + settings.SpacerPixels;
peakProvider.Init(reader, samplesPerPixel * stepSize);
return(GetInfo(peakProvider, settings));
}
}
public Image Render(string selectedFile, IPeakProvider peakProvider, WaveFormRendererSettings settings)
{
using (var reader = new AudioFileReader(selectedFile))
{
int bytesPerSample = (reader.WaveFormat.BitsPerSample / 8);
var samples = reader.Length / (bytesPerSample);
var values = read(selectedFile, samples);
var frames = splitToFrames(values);
var samplesPerPixel = (int)(samples / settings.Width);
var stepSize = settings.PixelsPerPeak + settings.SpacerPixels;
peakProvider.Init(reader, samplesPerPixel * stepSize);
this.OnReadHandler?.Invoke(reader.WaveFormat, frames);
return(Render(peakProvider, settings));
}
}
public Image Render(string selectedFile, IPeakProvider peakProvider, WaveFormRendererSettings settings, ILogger log)
{
Log.Logger = log;
using (reader = new AudioFileReader(selectedFile))
{
int bytesPerSample = (reader.WaveFormat.BitsPerSample / 8);
Log.Information(rrender + "Bytes Per Sample: {0}", bytesPerSample);
var samples = reader.Length / (bytesPerSample);
Log.Information(rrender + "Samples: {0}", samples);
var samplesPerPixel = (int)(samples / settings.Width);
Log.Information(rrender + "Samples Per Pixel: {0}", samplesPerPixel);
var stepSize = settings.PixelsPerPeak + settings.SpacerPixels;
Log.Information(rrender + "Step Size: {0}", stepSize);
peakProvider.Init(reader, samplesPerPixel * stepSize);
return(Render(peakProvider, settings));
}
}
private float[] ArrangeWF(IPeakProvider peakProvider)
{
long x = 0;
long i = 0;
var currentPeak = peakProvider.GetNextPeak();
while (x < samples)
{
//Console.WriteLine("i={0} x={1} ", i, x); //デバッグ用
var nextPeak = peakProvider.GetNextPeak();
waveValuePerBlock[i] = currentPeak.Max;
i++;
x = i * samplePerBlock;
currentPeak = nextPeak;
}
return(waveValuePerBlock);
}
public float[] ArrangeWF(string selectedFile, IPeakProvider peakProvider)
{
using (var reader = new AudioFileReader(selectedFile))
{
sampleRate = (reader.WaveFormat.SampleRate);
samplePerBlock = sampleRate * BLOCKTIMEms / 1000;
int bytesPerSample = (reader.WaveFormat.BitsPerSample / 8);
samples = reader.Length / reader.WaveFormat.BlockAlign;
waveValuePerBlock = new float[(samples / samplePerBlock) + 1];
blockAlign = reader.WaveFormat.BlockAlign;
//// デバッグ用
//Console.WriteLine("BlockAlign= {0}", reader.WaveFormat.BlockAlign);
//Console.WriteLine("AverageBytesPerSecond = {0}", reader.WaveFormat.AverageBytesPerSecond);
//Console.WriteLine("SampleRate {0}", reader.WaveFormat.SampleRate);
//Console.WriteLine("Channels {0}", reader.WaveFormat.Channels);
//Console.WriteLine("ExtraSize {0}", reader.WaveFormat.ExtraSize);
//Console.WriteLine("BitsPerSample {0}", reader.WaveFormat.BitsPerSample);
//Console.WriteLine("Length {0}", reader.Length);
peakProvider.Init(reader, samplePerBlock * reader.WaveFormat.Channels);
return(ArrangeWF(peakProvider));
}
}
public NAudioGetWaveform(IWaveProviderFactory waveProviderFactory = null, IPeakProvider peakProvider = null)
{
_waveProviderFactory = waveProviderFactory ?? new WaveProviderFactory();
_peakProvider = peakProvider ?? new PeakProvider();
}
public DecibelPeakProvider(IPeakProvider sourceProvider, double dynamicRange)
{
this.sourceProvider = sourceProvider;
this.dynamicRange = dynamicRange;
}
private static Image Render(IPeakProvider peakProvider, WaveFormRendererSettings settings, CancellationToken?ct = null)
{
ct?.ThrowIfCancellationRequested();
if (settings.DecibelScale)
{
peakProvider = new DecibelPeakProvider(peakProvider, 48);
}
var b = new Bitmap(settings.Width, settings.TopHeight + settings.BottomHeight);
if (settings.BackgroundColor == Color.Transparent)
{
b.MakeTransparent();
}
ct?.ThrowIfCancellationRequested();
using (var g = Graphics.FromImage(b))
{
g.FillRectangle(settings.BackgroundBrush, 0, 0, b.Width, b.Height);
var midPoint = settings.TopHeight;
int x = 0;
var currentPeak = peakProvider.GetNextPeak();
while (x < settings.Width)
{
ct?.ThrowIfCancellationRequested();
var nextPeak = peakProvider.GetNextPeak();
for (int n = 0; n < settings.PixelsPerPeak; n++)
{
ct?.ThrowIfCancellationRequested();
var lineHeight = settings.TopHeight * currentPeak.Max;
if (settings.TopPeakPen != null)
{
g.DrawLine(settings.TopPeakPen, x, midPoint, x, midPoint - lineHeight);
}
lineHeight = settings.BottomHeight * currentPeak.Min;
if (settings.BottomPeakPen != null)
{
g.DrawLine(settings.BottomPeakPen, x, midPoint, x, midPoint - lineHeight);
}
x++;
}
for (int n = 0; n < settings.SpacerPixels; n++)
{
ct?.ThrowIfCancellationRequested();
// spacer bars are always the lower of the
var max = Math.Min(currentPeak.Max, nextPeak.Max);
var min = Math.Max(currentPeak.Min, nextPeak.Min);
var lineHeight = settings.TopHeight * max;
if (settings.TopSpacerPen != null)
{
g.DrawLine(settings.TopSpacerPen, x, midPoint, x, midPoint - lineHeight);
}
lineHeight = settings.BottomHeight * min;
if (settings.BottomSpacerPen != null)
{
g.DrawLine(settings.BottomSpacerPen, x, midPoint, x, midPoint - lineHeight);
}
x++;
}
currentPeak = nextPeak;
}
}
return(b);
}
public Image Render(string selectedFile, IPeakProvider peakProvider, WaveFormRendererSettings settings)
{
return(Render(selectedFile, peakProvider, settings, (a) => new AudioFileReader(a)));
}
public SamplesHandlerPeakPublisher(IEventAggregator events, IPeakProvider peakProvider)
{
_events = events ?? throw new ArgumentNullException(nameof(events));
_peakProvider = peakProvider ?? throw new ArgumentNullException(nameof(peakProvider));
_events.Subscribe(this);
}
