public static void RenderSeperate(WaveFormRendererData rendererData, BitmapHelper.RenderInfo waveRenderInfo, BitmapHelper.RenderInfo powerRenderInfo, bool rms)
{
if (rms)
{
var waveElements = rendererData.WaveElements;
var powerElements = rendererData.PowerElements;
for (var position = 0; position < rendererData.Position; position++)
{
for (var channel = 0; channel < rendererData.Channels; channel++)
{
var waveElement = waveElements[position, channel];
var powerElement = powerElements[position, channel];
BitmapHelper.DrawRectangle(
waveRenderInfo,
position,
waveElement.Y,
1,
waveElement.Height
);
BitmapHelper.DrawRectangle(
powerRenderInfo,
position,
powerElement.Y,
1,
powerElement.Height
);
}
}
}
else
{
var elements = rendererData.WaveElements;
for (var position = 0; position < rendererData.Position; position++)
{
for (var channel = 0; channel < rendererData.Channels; channel++)
{
var element = elements[position, channel];
BitmapHelper.DrawRectangle(
waveRenderInfo,
position,
element.Y,
1,
element.Height
);
}
}
}
}
public static void Render(WaveFormRendererData rendererData, BitmapHelper.RenderInfo waveRenderInfo, BitmapHelper.RenderInfo powerRenderInfo, bool rms, WaveFormRendererMode mode)
{
BitmapHelper.Clear(waveRenderInfo);
switch (mode)
{
case WaveFormRendererMode.Mono:
RenderMono(rendererData, waveRenderInfo, powerRenderInfo, rms);
break;
case WaveFormRendererMode.Seperate:
RenderSeperate(rendererData, waveRenderInfo, powerRenderInfo, rms);
break;
default:
throw new NotImplementedException();
}
}
private static void UpdateSeperate(WaveFormGenerator.WaveFormGeneratorData generatorData, WaveFormRendererData rendererData, bool rms)
{
var factor = rendererData.NormalizedPeak / generatorData.Channels;
if (factor == 0)
{
//Peak has not been calculated.
//I don't know how this happens, but it does.
return;
}
var data = generatorData.Data;
var waveElements = rendererData.WaveElements;
var powerElements = rendererData.PowerElements;
var valuesPerElement = rendererData.ValuesPerElement;
while (rendererData.Position < rendererData.Capacity)
{
var valuePosition = rendererData.Position * rendererData.ValuesPerElement;
if ((valuePosition + rendererData.ValuesPerElement) > generatorData.Position)
{
if (generatorData.Position <= generatorData.Capacity)
{
break;
}
else
{
valuesPerElement = generatorData.Capacity - valuePosition;
}
}
var waveHeight = rendererData.Height / generatorData.Channels;
for (var channel = 0; channel < generatorData.Channels; channel++)
{
var waveCenter = (waveHeight * channel) + (waveHeight / 2);
{
var y = default(int);
var height = default(int);
var topValue = default(float);
var bottomValue = default(float);
for (var a = 0; a < valuesPerElement; a++)
{
topValue += Math.Abs(data[valuePosition + a, channel].Min);
bottomValue += Math.Abs(data[valuePosition + a, channel].Max);
}
topValue /= (valuesPerElement * generatorData.Channels);
bottomValue /= (valuesPerElement * generatorData.Channels);
topValue /= factor;
bottomValue /= factor;
topValue = Math.Min(topValue, 1);
bottomValue = Math.Min(bottomValue, 1);
y = Convert.ToInt32(waveCenter - (topValue * (waveHeight / 2)));
height = Convert.ToInt32((waveCenter - y) + (bottomValue * (waveHeight / 2)));
waveElements[rendererData.Position, channel].Y = y;
waveElements[rendererData.Position, channel].Height = height;
}
if (rms)
{
var y = default(int);
var height = default(int);
var value = default(float);
for (var a = 0; a < valuesPerElement; a++)
{
value += Math.Abs(data[valuePosition + a, channel].Rms);
}
value /= (valuesPerElement * generatorData.Channels);
value /= factor;
value = Math.Min(value, 1);
y = Convert.ToInt32(waveCenter - (value * (waveHeight / 2)));
height = Convert.ToInt32((waveCenter - y) + (value * (waveHeight / 2)));
powerElements[rendererData.Position, channel].Y = y;
powerElements[rendererData.Position, channel].Height = height;
}
}
rendererData.Position++;
}
}
public static float GetPeak(WaveFormGenerator.WaveFormGeneratorData generatorData, WaveFormRendererData rendererData)
{
var data = generatorData.Data;
var valuesPerElement = rendererData.ValuesPerElement;
var peak = rendererData.NormalizedPeak;
var position = rendererData.Position;
while (position < rendererData.Capacity)
{
var valuePosition = position * rendererData.ValuesPerElement;
if ((valuePosition + rendererData.ValuesPerElement) > generatorData.Position)
{
if (generatorData.Position <= generatorData.Capacity)
{
break;
}
else
{
valuesPerElement = generatorData.Capacity - valuePosition;
}
}
var value = default(float);
for (var a = 0; a < valuesPerElement; a++)
{
for (var b = 0; b < generatorData.Channels; b++)
{
value += Math.Max(
Math.Abs(data[valuePosition + a, b].Min),
Math.Abs(data[valuePosition + a, b].Max)
);
}
}
value /= (valuesPerElement * generatorData.Channels);
peak = Math.Max(peak, value);
if (peak >= 1)
{
return(1);
}
position++;
}
return(peak);
}
private static void Update(WaveFormGenerator.WaveFormGeneratorData generatorData, WaveFormRendererData rendererData, bool rms, WaveFormRendererMode mode)
{
if (generatorData.Peak == 0)
{
return;
}
else if (generatorData.Peak != rendererData.Peak)
{
rendererData.Position = 0;
rendererData.Peak = generatorData.Peak;
rendererData.NormalizedPeak = GetPeak(generatorData, rendererData);
}
switch (mode)
{
case WaveFormRendererMode.Mono:
UpdateMono(generatorData, rendererData, rms);
break;
case WaveFormRendererMode.Seperate:
UpdateSeperate(generatorData, rendererData, rms);
break;
default:
throw new NotImplementedException();
}
}
