[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
}

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Media;
using System.Windows.Media.Imaging;
using System.Windows.Threading;
using Un4seen.Bass;

namespace BandedSpectrumAnalyzer
{
    /// <summary>
    /// Interaction logic for SpectrumAnalyzer.xaml
    /// </summary>
    public partial class SpectrumAnalyzer : UserControl
    {
        #region Fields
        private DispatcherTimer animationTimer;
        private RenderTargetBitmap anaylzerBuffer;
        private DrawingVisual drawingVisual = new DrawingVisual();
        private float[] channelData = new float[2048];
        private float[] channelPeakData;
        private int scaleFactorLinear = 9;
        private int scaleFactorSqr = 2;
        private int maxFFTData = 4096;
        private BASSData maxFFT = (BASSData.BASS_DATA_AVAILABLE | BASSData.BASS_DATA_FFT4096);
        private double bandWidth = 1.0;
        private double barWidth = 1;
        private int maximumFrequencyIndex = 2047;
        private int minimumFrequencyIndex = 0;
        private int sampleFrequency = 44100;
        private int[] barIndexMax;
        private int[] barLogScaleIndexMax;
        private BassEngine bassEngine;
        #endregion

        #region Dependency Property Declarations
        public static readonly DependencyProperty MaximumFrequencyProperty;
        public static readonly DependencyProperty MinimumFrequencyProperty;
        public static readonly DependencyProperty BarCountProperty;
        public static readonly DependencyProperty BarSpacingProperty;
        public static readonly DependencyProperty PeakFallDelayProperty;

        protected static readonly DependencyProperty StreamHandleProperty =
            DependencyProperty.Register("StreamHandle",
            typeof(int),
            typeof(SpectrumAnalyzer));

        public static readonly DependencyProperty FrequencyScaleIsLinearProperty =
            DependencyProperty.Register("FrequencyScaleIsLinear",
            typeof(bool),
            typeof(SpectrumAnalyzer));


        public static readonly DependencyProperty BarHeightScalingProperty =
            DependencyProperty.Register("BarHeightScaling",
            typeof(BarHeightScaling),
            typeof(SpectrumAnalyzer));

        public static readonly DependencyProperty AveragePeaksProperty =
            DependencyProperty.Register("AveragePeaks",
            typeof(bool),
            typeof(SpectrumAnalyzer));

        public static readonly DependencyProperty BarBrushProperty =
            DependencyProperty.Register("BarBrush",
            typeof(Brush),
            typeof(SpectrumAnalyzer));

        public static readonly DependencyProperty PeakBrushProperty =
            DependencyProperty.Register("PeakBrush",
            typeof(Brush),
            typeof(SpectrumAnalyzer));
        #endregion

        #region Dependency Properties
        /// <summary>
        /// The maximum display frequency (right side) for the spectrum analyzer.
        /// </summary>
        /// <remarks>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
        {
            get { return (int)GetValue(MaximumFrequencyProperty); }
            set
            {
                SetValue(MaximumFrequencyProperty, value);
            }
        }

        /// <summary>
        /// The minimum display frequency (left side) for the spectrum analyzer.
        /// </summary>
        [Category("Common")]
        public int MinimumFrequency
        {
            get { return (int)GetValue(MinimumFrequencyProperty); }
            set
            {
                SetValue(MinimumFrequencyProperty, value);
            }
        }

        /// <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
        {
            get { return (int)GetValue(BarCountProperty); }
            set
            {
                SetValue(BarCountProperty, value);
            }
        }

        /// <summary>
        /// The brush used to paint the bars on the spectrum analyzer.
        /// </summary>
        [Category("Common")]
        public Brush BarBrush
        {
            get { return (Brush)GetValue(BarBrushProperty); }
            set
            {
                SetValue(BarBrushProperty, value);
            }
        }

        /// <summary>
        /// The brush used to paint the peaks on the spectrum analyzer.
        /// </summary>
        [Category("Common")]
        public Brush PeakBrush
        {
            get { return (Brush)GetValue(PeakBrushProperty); }
            set
            {
                SetValue(PeakBrushProperty, value);
            }
        }

        /// <summary>
        /// The delay factor for the peaks falling. This is relative to the
        /// refresh rate of the chart.
        /// </summary>
        [Category("Common")]
        public int PeakFallDelay
        {
            get { return (int)GetValue(PeakFallDelayProperty); }
            set
            {
                SetValue(PeakFallDelayProperty, value);
            }
        }

        /// <summary>
        /// The spacing, in pixels, between the bars.
        /// </summary>
        [Category("Common")]
        public double BarSpacing
        {
            get { return (double)GetValue(BarSpacingProperty); }
            set
            {
                SetValue(BarSpacingProperty, value);
            }
        }

        /// <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 BarHeightScaling BarHeightScaling
        {
            get { return (BarHeightScaling)GetValue(BarHeightScalingProperty); }
            set
            {
                SetValue(BarHeightScalingProperty, value);
            }
        }

        /// <summary>
        /// If true, this will display the frequency scale (X-axis of the spectrum analyzer)
        /// in a linear scale. Otherwise, the scale will be logrithmic.
        /// </summary>
        [Category("Common")]
        public bool FrequencyScaleIsLinear
        {
            get { return (bool)GetValue(FrequencyScaleIsLinearProperty); }
            set
            {
                SetValue(FrequencyScaleIsLinearProperty, value);
            }
        }

        /// <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
        {
            get { return (bool)GetValue(AveragePeaksProperty); }
            set
            {
                SetValue(AveragePeaksProperty, value);
            }
        }

        protected int StreamHandle
        {
            get { return (int)GetValue(StreamHandleProperty); }
            set
            {
                SetValue(StreamHandleProperty, value);
                if (StreamHandle != 0)
                {
                    BASS_CHANNELINFO info = new BASS_CHANNELINFO();
                    Bass.BASS_ChannelGetInfo(StreamHandle, info);
                    sampleFrequency = info.freq;
                }
                else
                {
                    sampleFrequency = 44100;
                }
                BarMappingChanged(this, EventArgs.Empty);
            }
        }
        #endregion

        #region Dependency Property Validation
        private static object CoerceMaximumFrequency(DependencyObject d, object value)
        {
            SpectrumAnalyzer spectrumAnalyzer = (SpectrumAnalyzer)d;
            if ((int)value < spectrumAnalyzer.MinimumFrequency)
                return spectrumAnalyzer.MinimumFrequency + 1;
            return value;
        }

        private static object CoerceMinimumFrequency(DependencyObject d, object value)
        {
            int returnValue = (int)value;
            SpectrumAnalyzer spectrumAnalyzer = (SpectrumAnalyzer)d;
            if (returnValue < 0)
                return returnValue = 0;
            spectrumAnalyzer.CoerceValue(MaximumFrequencyProperty);
            return returnValue;
        }

        private static object CoerceBarCount(DependencyObject d, object value)
        {
            int returnValue = (int)value;
            returnValue = Math.Max(returnValue, 1);
            return returnValue;
        }

        private static object CoercePeakFallDelay(DependencyObject d, object value)
        {
            int returnValue = (int)value;
            returnValue = Math.Max(returnValue, 0);
            return returnValue;
        }

        private static object CoerceBarSpacing(DependencyObject d, object value)
        {
            double returnValue = (double)value;
            returnValue = Math.Max(returnValue, 0);
            return returnValue;
        }
        #endregion

        #region Constructors
        static SpectrumAnalyzer()
        {
            // MaximumFrequency
            FrameworkPropertyMetadata maximumFrequencyMetadata = new FrameworkPropertyMetadata(20000);
            maximumFrequencyMetadata.CoerceValueCallback = new CoerceValueCallback(SpectrumAnalyzer.CoerceMaximumFrequency);
            MaximumFrequencyProperty = DependencyProperty.Register("MaximumFrequency", typeof(int), typeof(SpectrumAnalyzer), maximumFrequencyMetadata);

            // MinimumFrequency
            FrameworkPropertyMetadata minimumFrequencyMetadata = new FrameworkPropertyMetadata(0);
            minimumFrequencyMetadata.CoerceValueCallback = new CoerceValueCallback(SpectrumAnalyzer.CoerceMinimumFrequency);
            MinimumFrequencyProperty = DependencyProperty.Register("MinimumFrequency", typeof(int), typeof(SpectrumAnalyzer), minimumFrequencyMetadata);

            // BarCount
            FrameworkPropertyMetadata barCountMetadata = new FrameworkPropertyMetadata(24);
            barCountMetadata.CoerceValueCallback = new CoerceValueCallback(SpectrumAnalyzer.CoerceBarCount);
            BarCountProperty = DependencyProperty.Register("BarCount", typeof(int), typeof(SpectrumAnalyzer), barCountMetadata);

            // BarSpacing
            FrameworkPropertyMetadata barSpacingMetadata = new FrameworkPropertyMetadata(5.0);
            barSpacingMetadata.CoerceValueCallback = new CoerceValueCallback(SpectrumAnalyzer.CoerceBarSpacing);
            BarSpacingProperty = DependencyProperty.Register("BarSpacing", typeof(double), typeof(SpectrumAnalyzer), barSpacingMetadata);

            // PeakFallDelay
            FrameworkPropertyMetadata peakFallDelayMetadata = new FrameworkPropertyMetadata(5);
            peakFallDelayMetadata.CoerceValueCallback = new CoerceValueCallback(SpectrumAnalyzer.CoercePeakFallDelay);
            PeakFallDelayProperty = DependencyProperty.Register("PeakFallDelay", typeof(int), typeof(SpectrumAnalyzer), peakFallDelayMetadata);
        }

        public SpectrumAnalyzer()
        {
            PeakBrush = new SolidColorBrush(Colors.GreenYellow);
            BarBrush = new LinearGradientBrush(Colors.ForestGreen, Colors.DarkGreen, new Point(0, 1), new Point(0, 0));

            InitializeComponent();

            animationTimer = new DispatcherTimer(DispatcherPriority.ApplicationIdle);
            animationTimer.Interval = TimeSpan.FromMilliseconds(25);
            animationTimer.Tick += new EventHandler(animationTimer_Tick);

            DependencyPropertyDescriptor backgroundDescriptor = DependencyPropertyDescriptor.FromProperty(BackgroundProperty, typeof(SpectrumAnalyzer));
            backgroundDescriptor.AddValueChanged(this, AppearanceChanged);
            DependencyPropertyDescriptor barBrushDescriptor = DependencyPropertyDescriptor.FromProperty(BarBrushProperty, typeof(SpectrumAnalyzer));
            barBrushDescriptor.AddValueChanged(this, AppearanceChanged);

            DependencyPropertyDescriptor maxFrequencyDescriptor = DependencyPropertyDescriptor.FromProperty(MaximumFrequencyProperty, typeof(SpectrumAnalyzer));
            maxFrequencyDescriptor.AddValueChanged(this, BarMappingChanged);
            DependencyPropertyDescriptor minFrequencyDescriptor = DependencyPropertyDescriptor.FromProperty(MinimumFrequencyProperty, typeof(SpectrumAnalyzer));
            maxFrequencyDescriptor.AddValueChanged(this, BarMappingChanged);
            DependencyPropertyDescriptor barCountDescriptor = DependencyPropertyDescriptor.FromProperty(BarCountProperty, typeof(SpectrumAnalyzer));
            maxFrequencyDescriptor.AddValueChanged(this, BarMappingChanged);

            BarMappingChanged(this, EventArgs.Empty);

            if (!DesignerProperties.GetIsInDesignMode(this))
            {
                bassEngine = BassEngine.Instance;
                UIHelper.Bind(bassEngine, "ActiveStreamHandle", this, StreamHandleProperty);
                animationTimer.Start();
            }
        }

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

        #region Event Overrides
        protected override void OnRender(DrawingContext dc)
        {
            base.OnRender(dc);
            anaylzerBuffer = new RenderTargetBitmap((int)RenderSize.Width, (int)RenderSize.Height, 96, 96, PixelFormats.Pbgra32);
            if (SpectrumImage != null)
            {
                SpectrumImage.Source = anaylzerBuffer;
            }
            UpdateSpectrum();
        }

        protected override void OnRenderSizeChanged(SizeChangedInfo sizeInfo)
        {
            base.OnRenderSizeChanged(sizeInfo);
            BarMappingChanged(this, EventArgs.Empty);
        }
        #endregion

        #region Private Utility Methods
        private void UpdateSpectrum()
        {
            if (bassEngine == null || drawingVisual == null || anaylzerBuffer == null || RenderSize.Width < 1 || RenderSize.Height < 1)
                return;

            if (!bassEngine.IsPaused && (StreamHandle == 0 || (GetFFTBuffer(StreamHandle, (int)maxFFT) < 1)))
                return;

            // Clear Canvas
            anaylzerBuffer.Clear();

            using (DrawingContext drawingContext = drawingVisual.RenderOpen())
            {
                // Draw background if applicable.    
                if (Background != null)
                    drawingContext.DrawRectangle(Background, null, new Rect(0, 0, RenderSize.Width, RenderSize.Height));

                // Draw Spectrum Lines
                RenderSpectrumLines(drawingContext);
            }

            anaylzerBuffer.Render(drawingVisual);
        }

        private int GetFFTBuffer(int handle, int length)
        {
            return Un4seen.Bass.Bass.BASS_ChannelGetData(handle, this.channelData, length);
        }

        private void RenderSpectrumLines(DrawingContext dc)
        {
            double fftBucketHeight = 0f;
            double barHeight = 0f;
            double lastPeakHeight = 0f;
            double peakYPos = 0f;
            double height = this.RenderSize.Height;
            int barIndex = 0;
            double peakDotHeight = Math.Max(barWidth / 2.0f, 1);
            double barHeightScale = (height - peakDotHeight);
            const double minDBValue = -90;
            const double maxDBValue = 0;
            const double dbScale = (maxDBValue - minDBValue);

            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 (bassEngine.IsPaused)
                {
                    barHeight = 0f;
                }
                else // Draw the maximum value for the bar's band
                {
                    switch (BarHeightScaling)
                    {
                        case BandedSpectrumAnalyzer.BarHeightScaling.Decibel:
                            double dbValue = 20 * Math.Log10((double)channelData[i]);
                            fftBucketHeight = ((dbValue - minDBValue) / dbScale) * barHeightScale;
                            break;
                        case BandedSpectrumAnalyzer.BarHeightScaling.Linear:
                            fftBucketHeight = (channelData[i] * scaleFactorLinear) * barHeightScale;
                            break;
                        case BandedSpectrumAnalyzer.BarHeightScaling.Sqrt:
                            fftBucketHeight = (((Math.Sqrt((double)this.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 = FrequencyScaleIsLinear ? 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)
                        this.channelPeakData[barIndex] = (float)peakYPos;
                    else
                        this.channelPeakData[barIndex] = (float)(peakYPos + (PeakFallDelay * this.channelPeakData[barIndex])) / ((float)(PeakFallDelay + 1));

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

                    // Draw the bars
                    if (BarBrush != null)
                        dc.DrawRectangle(BarBrush, null, new Rect(xCoord, (height - 1) - barHeight, barWidth, barHeight));

                    // Draw the peaks
                    if (PeakBrush != null)
                        dc.DrawRectangle(PeakBrush, null, new Rect(xCoord, (height - 1) - this.channelPeakData[barIndex], barWidth, peakDotHeight));

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

        #region Dependency Property Changed Handlers
        private void AppearanceChanged(object sender, EventArgs e)
        {
            UpdateSpectrum();
        }

        private void BarMappingChanged(object sender, EventArgs e)
        {
            barWidth = Math.Max((int)((RenderSize.Width - (BarSpacing * (BarCount + 1))) / (double)BarCount), 1);
            maximumFrequencyIndex = Math.Min(Utils.FFTFrequency2Index(MaximumFrequency, maxFFTData, sampleFrequency) + 1, 2047);
            minimumFrequencyIndex = Math.Min(Utils.FFTFrequency2Index(MinimumFrequency, maxFFTData, sampleFrequency), 2047);
            bandWidth = Math.Max(((double)(maximumFrequencyIndex - minimumFrequencyIndex)) / RenderSize.Width, 1.0);

            int actualBarCount = Math.Max((int)((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 - 1; i++)
            {
                maxIndexList.Add(minimumFrequencyIndex + (i * linearIndexBucketSize));
                int logIndex = (int)((maxLog - Math.Log(actualBarCount - i, actualBarCount)) * indexCount) + minimumFrequencyIndex;
                maxLogScaleIndexList.Add(logIndex);
            }
            maxIndexList.Add(maximumFrequencyIndex);
            maxLogScaleIndexList.Add(maximumFrequencyIndex);
            barIndexMax = maxIndexList.ToArray();
            barLogScaleIndexMax = maxLogScaleIndexList.ToArray();
        }
        #endregion
    }

    public enum BarHeightScaling
    {
        Decibel,
        Sqrt,
        Linear
    }
}