A WPF Spectrum Analyzer for Audio Visualization (C#) – Part 2: The WPFening

[TemplatePart(Name = "PART_SpectrumCanvas", Type = typeof(Canvas))]    
public class SpectrumAnalyzer : Control
{
    #region Fields
    private readonly DispatcherTimer animationTimer;
    private Canvas spectrumCanvas;
    private ISpectrumPlayer soundPlayer;
    private readonly List<Shape> barShapes = new List<Shape>();
    private readonly List<Shape> peakShapes = new List<Shape>();
    private double[] barHeights;
    private double[] peakHeights;
    private float[] channelData = new float[2048];
    private float[] channelPeakData;
    private double bandWidth = 1.0;
    private double barWidth = 1;
    private int maximumFrequencyIndex = 2047;
    private int minimumFrequencyIndex;
    private int[] barIndexMax;
    private int[] barLogScaleIndexMax;
    #endregion

    #region Constants
    private const int scaleFactorLinear = 9;
    private const int scaleFactorSqr = 2;
    private const double minDBValue = -90;
    private const double maxDBValue = 0;
    private const double dbScale = (maxDBValue - minDBValue);
    #endregion

    #region Dependency Properties
    #region MaximumFrequency
    public static readonly DependencyProperty MaximumFrequencyProperty = DependencyProperty.Register("MaximumFrequency", typeof(int), typeof(SpectrumAnalyzer), new UIPropertyMetadata(20000, OnMaximumFrequencyChanged, OnCoerceMaximumFrequency));

    private static object OnCoerceMaximumFrequency(DependencyObject o, object value)
    {
        SpectrumAnalyzer spectrumAnalyzer = o as SpectrumAnalyzer;
        if (spectrumAnalyzer != null)
            return spectrumAnalyzer.OnCoerceMaximumFrequency((int)value);
        else
            return value;
    }

    private static void OnMaximumFrequencyChanged(DependencyObject o, DependencyPropertyChangedEventArgs e)
    {
        SpectrumAnalyzer spectrumAnalyzer = o as SpectrumAnalyzer;
        if (spectrumAnalyzer != null)
            spectrumAnalyzer.OnMaximumFrequencyChanged((int)e.OldValue, (int)e.NewValue);
    }

    protected virtual int OnCoerceMaximumFrequency(int value)
    {
        if ((int)value < MinimumFrequency)
            return MinimumFrequency + 1;
        return value;
    }

    protected virtual void OnMaximumFrequencyChanged(int oldValue, int newValue)
    {
        UpdateBarLayout();
    }

    /// <summary>
    /// The maximum display frequency (right side) for the spectrum analyzer.
    /// </summary>
    /// <remarks>In usual practice, this value should be somewhere between 0 and half of the maximum sample rate. If using
    /// the maximum sample rate, this would be roughly 22000.</remarks>
    [Category("Common")]
    public int MaximumFrequency
    {
        // IMPORTANT: To maintain parity between setting a property in XAML and procedural code, do not touch the getter and setter inside this dependency property!
        get
        {
            return (int)GetValue(MaximumFrequencyProperty);
        }
        set
        {
            SetValue(MaximumFrequencyProperty, value);
        }
    }
    #endregion

    #region Minimum Frequency
    public static readonly DependencyProperty MinimumFrequencyProperty = DependencyProperty.Register("MinimumFrequency", typeof(int), typeof(SpectrumAnalyzer), new UIPropertyMetadata(20, OnMinimumFrequencyChanged, OnCoerceMinimumFrequency));

    private static object OnCoerceMinimumFrequency(DependencyObject o, object value)
    {
        SpectrumAnalyzer spectrumAnalyzer = o as SpectrumAnalyzer;
        if (spectrumAnalyzer != null)
            return spectrumAnalyzer.OnCoerceMinimumFrequency((int)value);
        else
            return value;
    }

    private static void OnMinimumFrequencyChanged(DependencyObject o, DependencyPropertyChangedEventArgs e)
    {
        SpectrumAnalyzer spectrumAnalyzer = o as SpectrumAnalyzer;
        if (spectrumAnalyzer != null)
            spectrumAnalyzer.OnMinimumFrequencyChanged((int)e.OldValue, (int)e.NewValue);
    }

    protected virtual int OnCoerceMinimumFrequency(int value)
    {
        if (value < 0)
            return value = 0;
        CoerceValue(MaximumFrequencyProperty);
        return value;
    }

    protected virtual void OnMinimumFrequencyChanged(int oldValue, int newValue)
    {
        UpdateBarLayout();
    }

    /// <summary>
    /// The minimum display frequency (left side) for the spectrum analyzer.
    /// </summary>
    [Category("Common")]
    public int MinimumFrequency
    {
        // IMPORTANT: To maintain parity between setting a property in XAML and procedural code, do not touch the getter and setter inside this dependency property!
        get
        {
            return (int)GetValue(MinimumFrequencyProperty);
        }
        set
        {
            SetValue(MinimumFrequencyProperty, value);
        }
    }

    #endregion

    #region BarCount
    public static readonly DependencyProperty BarCountProperty = DependencyProperty.Register("BarCount", typeof(int), typeof(SpectrumAnalyzer), new UIPropertyMetadata(32, OnBarCountChanged, OnCoerceBarCount));

    private static object OnCoerceBarCount(DependencyObject o, object value)
    {
        SpectrumAnalyzer spectrumAnalyzer = o as SpectrumAnalyzer;
        if (spectrumAnalyzer != null)
            return spectrumAnalyzer.OnCoerceBarCount((int)value);
        else
            return value;
    }

    private static void OnBarCountChanged(DependencyObject o, DependencyPropertyChangedEventArgs e)
    {
        SpectrumAnalyzer spectrumAnalyzer = o as SpectrumAnalyzer;
        if (spectrumAnalyzer != null)
            spectrumAnalyzer.OnBarCountChanged((int)e.OldValue, (int)e.NewValue);
    }

    protected virtual int OnCoerceBarCount(int value)
    {
        value = Math.Max(value, 1);
        return value;
    }

    protected virtual void OnBarCountChanged(int oldValue, int newValue)
    {
        UpdateBarLayout();
    }

    /// <summary>
    /// The number of bars to show on the sprectrum analyzer.
    /// </summary>
    /// <remarks>A bar's width can be a minimum of 1 pixel. If the BarSpacing and BarCount property result
    /// in the bars being wider than the chart itself, the BarCount will automatically scale down.</remarks>
    [Category("Common")]
    public int BarCount
    {
        // IMPORTANT: To maintain parity between setting a property in XAML and procedural code, do not touch the getter and setter inside this dependency property!
        get
        {
            return (int)GetValue(BarCountProperty);
        }
        set
        {
            SetValue(BarCountProperty, value);
        }
    }
    #endregion

    #region BarSpacing
    public static readonly DependencyProperty BarSpacingProperty = DependencyProperty.Register("BarSpacing", typeof(double), typeof(SpectrumAnalyzer), new UIPropertyMetadata(5.0d, OnBarSpacingChanged, OnCoerceBarSpacing));

    private static object OnCoerceBarSpacing(DependencyObject o, object value)
    {
        SpectrumAnalyzer spectrumAnalyzer = o as SpectrumAnalyzer;
        if (spectrumAnalyzer != null)
            return spectrumAnalyzer.OnCoerceBarSpacing((double)value);
        else
            return value;
    }

    private static void OnBarSpacingChanged(DependencyObject o, DependencyPropertyChangedEventArgs e)
    {
        SpectrumAnalyzer spectrumAnalyzer = o as SpectrumAnalyzer;
        if (spectrumAnalyzer != null)
            spectrumAnalyzer.OnBarSpacingChanged((double)e.OldValue, (double)e.NewValue);
    }

    protected virtual double OnCoerceBarSpacing(double value)
    {
        value = Math.Max(value, 0);
        return value;
    }

    protected virtual void OnBarSpacingChanged(double oldValue, double newValue)
    {
        UpdateBarLayout();
    }

    /// <summary>
    /// The spacing, in pixels, between the bars.
    /// </summary>
    [Category("Common")]
    public double BarSpacing
    {
        // IMPORTANT: To maintain parity between setting a property in XAML and procedural code, do not touch the getter and setter inside this dependency property!
        get
        {
            return (double)GetValue(BarSpacingProperty);
        }
        set
        {
            SetValue(BarSpacingProperty, value);
        }
    }
    #endregion

    #region PeakFallDelay
    public static readonly DependencyProperty PeakFallDelayProperty = DependencyProperty.Register("PeakFallDelay", typeof(int), typeof(SpectrumAnalyzer), new UIPropertyMetadata(10, OnPeakFallDelayChanged, OnCoercePeakFallDelay));

    private static object OnCoercePeakFallDelay(DependencyObject o, object value)
    {
        SpectrumAnalyzer spectrumAnalyzer = o as SpectrumAnalyzer;
        if (spectrumAnalyzer != null)
            return spectrumAnalyzer.OnCoercePeakFallDelay((int)value);
        else
            return value;
    }

    private static void OnPeakFallDelayChanged(DependencyObject o, DependencyPropertyChangedEventArgs e)
    {
        SpectrumAnalyzer spectrumAnalyzer = o as SpectrumAnalyzer;
        if (spectrumAnalyzer != null)
            spectrumAnalyzer.OnPeakFallDelayChanged((int)e.OldValue, (int)e.NewValue);
    }

    protected virtual int OnCoercePeakFallDelay(int value)
    {
        value = Math.Max(value, 0);
        return value;
    }

    protected virtual void OnPeakFallDelayChanged(int oldValue, int newValue)
    {

    }

    /// <summary>
    /// The delay factor for the peaks falling. This is relative to the
    /// refresh rate of the chart.
    /// </summary>
    [Category("Common")]
    public int PeakFallDelay
    {
        // IMPORTANT: To maintain parity between setting a property in XAML and procedural code, do not touch the getter and setter inside this dependency property!
        get
        {
            return (int)GetValue(PeakFallDelayProperty);
        }
        set
        {
            SetValue(PeakFallDelayProperty, value);
        }
    }
    #endregion

    #region IsFrequencyScaleLinear
    public static readonly DependencyProperty IsFrequencyScaleLinearProperty = DependencyProperty.Register("IsFrequencyScaleLinear", typeof(bool), typeof(SpectrumAnalyzer), new UIPropertyMetadata(false, OnIsFrequencyScaleLinearChanged, OnCoerceIsFrequencyScaleLinear));

    private static object OnCoerceIsFrequencyScaleLinear(DependencyObject o, object value)
    {
        SpectrumAnalyzer spectrumAnalyzer = o as SpectrumAnalyzer;
        if (spectrumAnalyzer != null)
            return spectrumAnalyzer.OnCoerceIsFrequencyScaleLinear((bool)value);
        else
            return value;
    }

    private static void OnIsFrequencyScaleLinearChanged(DependencyObject o, DependencyPropertyChangedEventArgs e)
    {
        SpectrumAnalyzer spectrumAnalyzer = o as SpectrumAnalyzer;
        if (spectrumAnalyzer != null)
            spectrumAnalyzer.OnIsFrequencyScaleLinearChanged((bool)e.OldValue, (bool)e.NewValue);
    }

    protected virtual bool OnCoerceIsFrequencyScaleLinear(bool value)
    {
        return value;
    }

    protected virtual void OnIsFrequencyScaleLinearChanged(bool oldValue, bool newValue)
    {
        UpdateBarLayout();
    }

    /// <summary>
    /// If true, the bars will represent frequency buckets on a linear scale (making them all
    /// have equal band widths on the frequency scale). Otherwise, the bars will be layed out
    /// on a logrithmic scale, with each bar having a larger bandwidth than the one previous.
    /// </summary>
    [Category("Common")]
    public bool IsFrequencyScaleLinear
    {
        // IMPORTANT: To maintain parity between setting a property in XAML and procedural code, do not touch the getter and setter inside this dependency property!
        get
        {
            return (bool)GetValue(IsFrequencyScaleLinearProperty);
        }
        set
        {
            SetValue(IsFrequencyScaleLinearProperty, value);
        }
    }
    #endregion

    #region BarHeightScaling
    public static readonly DependencyProperty BarHeightScalingProperty = DependencyProperty.Register("BarHeightScaling", typeof(BarHeightScalingStyles), typeof(SpectrumAnalyzer), new UIPropertyMetadata(BarHeightScalingStyles.Decibel, OnBarHeightScalingChanged, OnCoerceBarHeightScaling));

    private static object OnCoerceBarHeightScaling(DependencyObject o, object value)
    {
        SpectrumAnalyzer spectrumAnalyzer = o as SpectrumAnalyzer;
        if (spectrumAnalyzer != null)
            return spectrumAnalyzer.OnCoerceBarHeightScaling((BarHeightScalingStyles)value);
        else
            return value;
    }

    private static void OnBarHeightScalingChanged(DependencyObject o, DependencyPropertyChangedEventArgs e)
    {
        SpectrumAnalyzer spectrumAnalyzer = o as SpectrumAnalyzer;
        if (spectrumAnalyzer != null)
            spectrumAnalyzer.OnBarHeightScalingChanged((BarHeightScalingStyles)e.OldValue, (BarHeightScalingStyles)e.NewValue);
    }

    protected virtual BarHeightScalingStyles OnCoerceBarHeightScaling(BarHeightScalingStyles value)
    {
        return value;
    }

    protected virtual void OnBarHeightScalingChanged(BarHeightScalingStyles oldValue, BarHeightScalingStyles newValue)
    {

    }

    /// <summary>
    /// If true, the bar height will be displayed linearly with the intensity value.
    /// Otherwise, the bars will be scaled with a square root function.
    /// </summary>
    [Category("Common")]
    public BarHeightScalingStyles BarHeightScaling
    {
        // IMPORTANT: To maintain parity between setting a property in XAML and procedural code, do not touch the getter and setter inside this dependency property!
        get
        {
            return (BarHeightScalingStyles)GetValue(BarHeightScalingProperty);
        }
        set
        {
            SetValue(BarHeightScalingProperty, value);
        }
    }
    #endregion

    #region AveragePeaks
    public static readonly DependencyProperty AveragePeaksProperty = DependencyProperty.Register("AveragePeaks", typeof(bool), typeof(SpectrumAnalyzer), new UIPropertyMetadata(false, OnAveragePeaksChanged, OnCoerceAveragePeaks));

    private static object OnCoerceAveragePeaks(DependencyObject o, object value)
    {
        SpectrumAnalyzer spectrumAnalyzer = o as SpectrumAnalyzer;
        if (spectrumAnalyzer != null)
            return spectrumAnalyzer.OnCoerceAveragePeaks((bool)value);
        else
            return value;
    }

    private static void OnAveragePeaksChanged(DependencyObject o, DependencyPropertyChangedEventArgs e)
    {
        SpectrumAnalyzer spectrumAnalyzer = o as SpectrumAnalyzer;
        if (spectrumAnalyzer != null)
            spectrumAnalyzer.OnAveragePeaksChanged((bool)e.OldValue, (bool)e.NewValue);
    }

    protected virtual bool OnCoerceAveragePeaks(bool value)
    {
        return value;
    }

    protected virtual void OnAveragePeaksChanged(bool oldValue, bool newValue)
    {

    }

    /// <summary>
    /// If true, each bar's peak value will be averaged with the previous
    /// bar's peak. This creates a smoothing effect on the bars.
    /// </summary>
    [Category("Common")]
    public bool AveragePeaks
    {
        // IMPORTANT: To maintain parity between setting a property in XAML and procedural code, do not touch the getter and setter inside this dependency property!
        get
        {
            return (bool)GetValue(AveragePeaksProperty);
        }
        set
        {
            SetValue(AveragePeaksProperty, value);
        }
    }
    #endregion

    #region BarStyle
    public static readonly DependencyProperty BarStyleProperty = DependencyProperty.Register("BarStyle", typeof(Style), typeof(SpectrumAnalyzer), new UIPropertyMetadata(null, new PropertyChangedCallback(OnBarStyleChanged), new CoerceValueCallback(OnCoerceBarStyle)));

    private static object OnCoerceBarStyle(DependencyObject o, object value)
    {
        SpectrumAnalyzer spectrumAnalyzer = o as SpectrumAnalyzer;
        if (spectrumAnalyzer != null)
            return spectrumAnalyzer.OnCoerceBarStyle((Style)value);
        else
            return value;
    }

    private static void OnBarStyleChanged(DependencyObject o, DependencyPropertyChangedEventArgs e)
    {
        SpectrumAnalyzer spectrumAnalyzer = o as SpectrumAnalyzer;
        if (spectrumAnalyzer != null)
            spectrumAnalyzer.OnBarStyleChanged((Style)e.OldValue, (Style)e.NewValue);
    }

    protected virtual Style OnCoerceBarStyle(Style value)
    {
        return value;
    }

    protected virtual void OnBarStyleChanged(Style oldValue, Style newValue)
    {
        UpdateBarLayout();
    }

    /// <summary>
    /// A style with which to draw the bars on the spectrum analyzer.
    /// </summary>
    public Style BarStyle
    {
        // IMPORTANT: To maintain parity between setting a property in XAML and procedural code, do not touch the getter and setter inside this dependency property!
        get
        {
            return (Style)GetValue(BarStyleProperty);
        }
        set
        {
            SetValue(BarStyleProperty, value);
        }
    }
    #endregion

    #region PeakStyle
    public static readonly DependencyProperty PeakStyleProperty = DependencyProperty.Register("PeakStyle", typeof(Style), typeof(SpectrumAnalyzer), new UIPropertyMetadata(null, new PropertyChangedCallback(OnPeakStyleChanged), new CoerceValueCallback(OnCoercePeakStyle)));

    private static object OnCoercePeakStyle(DependencyObject o, object value)
    {
        SpectrumAnalyzer spectrumAnalyzer = o as SpectrumAnalyzer;
        if (spectrumAnalyzer != null)
            return spectrumAnalyzer.OnCoercePeakStyle((Style)value);
        else
            return value;
    }

    private static void OnPeakStyleChanged(DependencyObject o, DependencyPropertyChangedEventArgs e)
    {
        SpectrumAnalyzer spectrumAnalyzer = o as SpectrumAnalyzer;
        if (spectrumAnalyzer != null)
            spectrumAnalyzer.OnPeakStyleChanged((Style)e.OldValue, (Style)e.NewValue);
    }

    protected virtual Style OnCoercePeakStyle(Style value)
    {

        return value;
    }

    protected virtual void OnPeakStyleChanged(Style oldValue, Style newValue)
    {
        UpdateBarLayout();
    }

    /// <summary>
    /// A style with which to draw the falling peaks on the spectrum analyzer.
    /// </summary>
    public Style PeakStyle
    {
        // IMPORTANT: To maintain parity between setting a property in XAML and procedural code, do not touch the getter and setter inside this dependency property!
        get
        {
            return (Style)GetValue(PeakStyleProperty);
        }
        set
        {
            SetValue(PeakStyleProperty, value);
        }
    }
    #endregion

    #region ActualBarWidth
    public static readonly DependencyProperty ActualBarWidthProperty = DependencyProperty.Register("ActualBarWidth", typeof(double), typeof(SpectrumAnalyzer), new UIPropertyMetadata(0.0d, new PropertyChangedCallback(OnActualBarWidthChanged), new CoerceValueCallback(OnCoerceActualBarWidth)));

    private static object OnCoerceActualBarWidth(DependencyObject o, object value)
    {
        SpectrumAnalyzer spectrumAnalyzer = o as SpectrumAnalyzer;
        if (spectrumAnalyzer != null)
            return spectrumAnalyzer.OnCoerceActualBarWidth((double)value);
        else
            return value;
    }

    private static void OnActualBarWidthChanged(DependencyObject o, DependencyPropertyChangedEventArgs e)
    {
        SpectrumAnalyzer spectrumAnalyzer = o as SpectrumAnalyzer;
        if (spectrumAnalyzer != null)
            spectrumAnalyzer.OnActualBarWidthChanged((double)e.OldValue, (double)e.NewValue);
    }

    protected virtual double OnCoerceActualBarWidth(double value)
    {
        return value;
    }

    protected virtual void OnActualBarWidthChanged(double oldValue, double newValue)
    {

    }

    /// <summary>
    /// The actual width that the bars will be drawn at.
    /// </summary>
    public double ActualBarWidth
    {
        // IMPORTANT: To maintain parity between setting a property in XAML and procedural code, do not touch the getter and setter inside this dependency property!
        get
        {
            return (double)GetValue(ActualBarWidthProperty);
        }
        protected set
        {
            SetValue(ActualBarWidthProperty, value);
        }
    }

    #endregion
    #endregion

    #region Enums
    /// <summary>
    /// The different ways that the bar height can be scaled by the spectrum analyzer.
    /// </summary>
    public enum BarHeightScalingStyles
    {
        /// <summary>
        /// A decibel scale. Formula: 20 * Log10(FFTValue). Total bar height
        /// is scaled from -90 to 0 dB.
        /// </summary>
        Decibel,

        /// <summary>
        /// A non-linear squareroot scale. Formula: Sqrt(FFTValue) * 2 * BarHeight.
        /// </summary>
        Sqrt,

        /// <summary>
        /// A linear scale. Formula: 9 * FFTValue * BarHeight.
        /// </summary>
        Linear
    }

    /// <summary>
    /// The styles that the spectrum analyzer can draw the bars.
    /// </summary>
    public enum BarDrawingStyles
    {
        /// <summary>
        /// Square bars.
        /// </summary>
        Square,

        /// <summary>
        /// Rounded bars with the corner radius as half the
        /// bar width.
        /// </summary>
        Rounded
    }
    #endregion

    #region Template Overrides
    public override void OnApplyTemplate()
    {
        spectrumCanvas = GetTemplateChild("PART_SpectrumCanvas") as Canvas;
        UpdateBarLayout();
    }
    #endregion

    #region Constructors
    static SpectrumAnalyzer()
    {
        DefaultStyleKeyProperty.OverrideMetadata(typeof(SpectrumAnalyzer), new FrameworkPropertyMetadata(typeof(SpectrumAnalyzer)));
    }

    public SpectrumAnalyzer()
    {
        animationTimer = new DispatcherTimer(DispatcherPriority.ApplicationIdle)
        {
            Interval = TimeSpan.FromMilliseconds(25),
        };
        animationTimer.Tick += animationTimer_Tick;
    }
    #endregion

    #region Public Methods
    /// <summary>
    /// Register a sound player from which the spectrum analyzer
    /// can get the necessary playback data.
    /// </summary>
    /// <param name="soundPlayer">A sound player that provides spectrum data through the ISpectrumPlayer interface methods.</param>
    public void RegisterSoundPlayer(ISpectrumPlayer soundPlayer)
    {
        this.soundPlayer = soundPlayer;
        soundPlayer.PropertyChanged += soundPlayer_PropertyChanged;
        UpdateBarLayout();
        animationTimer.Start();
    }
    #endregion

    #region Event Overrides
    protected override void OnRender(DrawingContext dc)
    {
        base.OnRender(dc);
        UpdateBarLayout();
        UpdateSpectrum();
    }

    protected override void OnRenderSizeChanged(SizeChangedInfo sizeInfo)
    {
        base.OnRenderSizeChanged(sizeInfo);
        UpdateBarLayout();
        UpdateSpectrum();
    }
    #endregion

    #region Private Drawing Methods
    private void UpdateSpectrum()
    {
        if (soundPlayer == null || spectrumCanvas == null || spectrumCanvas.RenderSize.Width < 1 || spectrumCanvas.RenderSize.Height < 1)
            return;

        if (soundPlayer.IsPlaying && (soundPlayer.GetFFTData(channelData) < 1))
            return;

        UpdateSpectrumShapes();
    }


    private void UpdateSpectrumShapes()
    {
        bool allZero = true;
        double fftBucketHeight = 0f;
        double barHeight = 0f;
        double lastPeakHeight = 0f;
        double peakYPos = 0f;
        double height = spectrumCanvas.RenderSize.Height;
        int barIndex = 0;
        double peakDotHeight = Math.Max(barWidth / 2.0f, 1);
        double barHeightScale = (height - peakDotHeight);

        for (int i = minimumFrequencyIndex; i <= maximumFrequencyIndex; i++)
        {
            // If we're paused, keep drawing, but set the current height to 0 so the peaks fall.
            if (!soundPlayer.IsPlaying)
            {
                barHeight = 0f;
            }
            else // Draw the maximum value for the bar's band
            {
                switch (BarHeightScaling)
                {
                    case BarHeightScalingStyles.Decibel:
                        double dbValue = 20 * Math.Log10((double)channelData[i]);
                        fftBucketHeight = ((dbValue - minDBValue) / dbScale) * barHeightScale;
                        break;
                    case BarHeightScalingStyles.Linear:
                        fftBucketHeight = (channelData[i] * scaleFactorLinear) * barHeightScale;
                        break;
                    case BarHeightScalingStyles.Sqrt:
                        fftBucketHeight = (((Math.Sqrt((double)channelData[i])) * scaleFactorSqr) * barHeightScale);
                        break;
                }

                if (barHeight < fftBucketHeight)
                    barHeight = fftBucketHeight;
                if (barHeight < 0f)
                    barHeight = 0f;
            }

            // If this is the last FFT bucket in the bar's group, draw the bar.
            int currentIndexMax = IsFrequencyScaleLinear ? barIndexMax[barIndex] : barLogScaleIndexMax[barIndex];
            if (i == currentIndexMax)
            {
                // Peaks can't surpass the height of the control.
                if (barHeight > height)
                    barHeight = height;

                if (AveragePeaks && barIndex > 0)
                    barHeight = (lastPeakHeight + barHeight) / 2;

                peakYPos = barHeight;

                if (channelPeakData[barIndex] < peakYPos)
                    channelPeakData[barIndex] = (float)peakYPos;
                else
                    channelPeakData[barIndex] = (float)(peakYPos + (PeakFallDelay * channelPeakData[barIndex])) / ((float)(PeakFallDelay + 1));

                double xCoord = BarSpacing + (barWidth * barIndex) + (BarSpacing * barIndex) + 1;

                barShapes[barIndex].Margin = new Thickness(xCoord, (height - 1) - barHeight, 0, 0);
                barShapes[barIndex].Height = barHeight;
                peakShapes[barIndex].Margin = new Thickness(xCoord, (height - 1) - channelPeakData[barIndex] - peakDotHeight, 0, 0);
                peakShapes[barIndex].Height = peakDotHeight;

                if (channelPeakData[barIndex] > 0.05)
                    allZero = false;

                lastPeakHeight = barHeight;
                barHeight = 0f;
                barIndex++;
            }
        }

        if (allZero && !soundPlayer.IsPlaying)
            animationTimer.Stop();
    }

    private void UpdateBarLayout()
    {
        if (soundPlayer == null || spectrumCanvas == null)
            return;

        barWidth = Math.Max(((double)(spectrumCanvas.RenderSize.Width - (BarSpacing * (BarCount + 1))) / (double)BarCount), 1);
        maximumFrequencyIndex = Math.Min(soundPlayer.GetFFTFrequencyIndex(MaximumFrequency) + 1, 2047);
        minimumFrequencyIndex = Math.Min(soundPlayer.GetFFTFrequencyIndex(MinimumFrequency), 2047);
        bandWidth = Math.Max(((double)(maximumFrequencyIndex - minimumFrequencyIndex)) / spectrumCanvas.RenderSize.Width, 1.0);

        int actualBarCount;
        if (barWidth >= 1.0d)
            actualBarCount = BarCount;
        else
            actualBarCount = Math.Max((int)((spectrumCanvas.RenderSize.Width - BarSpacing) / (barWidth + BarSpacing)), 1);
        channelPeakData = new float[actualBarCount];

        int indexCount = maximumFrequencyIndex - minimumFrequencyIndex;
        int linearIndexBucketSize = (int)Math.Round((double)indexCount / (double)actualBarCount, 0);
        List<int> maxIndexList = new List<int>();
        List<int> maxLogScaleIndexList = new List<int>();
        double maxLog = Math.Log(actualBarCount, actualBarCount);
        for (int i = 1; i < actualBarCount; i++)
        {
            maxIndexList.Add(minimumFrequencyIndex + (i * linearIndexBucketSize));
            int logIndex = (int)((maxLog - Math.Log((actualBarCount + 1) - i, (actualBarCount + 1))) * indexCount) + minimumFrequencyIndex;
            maxLogScaleIndexList.Add(logIndex);
        }
        maxIndexList.Add(maximumFrequencyIndex);
        maxLogScaleIndexList.Add(maximumFrequencyIndex);
        barIndexMax = maxIndexList.ToArray();
        barLogScaleIndexMax = maxLogScaleIndexList.ToArray();

        barHeights = new double[actualBarCount];
        peakHeights = new double[actualBarCount];

        spectrumCanvas.Children.Clear();
        barShapes.Clear();
        peakShapes.Clear();

        double height = spectrumCanvas.RenderSize.Height;
        double peakDotHeight = Math.Max(barWidth / 2.0f, 1);
        for (int i = 0; i < actualBarCount; i++)
        {
            double xCoord = BarSpacing + (barWidth * i) + (BarSpacing * i) + 1;
            Rectangle barRectangle = new Rectangle()
            {
                Margin = new Thickness(xCoord, height, 0, 0),
                Width = barWidth,
                Height = 0,
                Style = BarStyle
            };
            barShapes.Add(barRectangle);
            Rectangle peakRectangle = new Rectangle()
            {
                Margin = new Thickness(xCoord, height - peakDotHeight, 0, 0),
                Width = barWidth,
                Height = peakDotHeight,
                Style = PeakStyle
            };
            peakShapes.Add(peakRectangle);
        }

        foreach (Shape shape in barShapes)
            spectrumCanvas.Children.Add(shape);
        foreach (Shape shape in peakShapes)
            spectrumCanvas.Children.Add(shape);

        ActualBarWidth = barWidth;
    }
    #endregion

    #region Event Handlers
    private void soundPlayer_PropertyChanged(object sender, PropertyChangedEventArgs e)
    {
        switch (e.PropertyName)
        {
            case "IsPlaying":
                if (soundPlayer.IsPlaying && !animationTimer.IsEnabled)
                    animationTimer.Start();
                break;
        }
    }

    private void animationTimer_Tick(object sender, EventArgs e)
    {
        UpdateSpectrum();
    }
    #endregion
}