Untitled

 package com.everydayflash.equalizer {

    import com.everydayflash.equalizer.util.SpectrumReader;

    import flash.display.*;
    import flash.display.BitmapData;
    import flash.events.Event;
    import flash.text.TextField;
    import flash.text.TextFieldAutoSize;
    import flash.text.TextFormat;

    public class Equalizer extends Sprite {

        public var canvas:BitmapData;
        private var canvasHolder:Bitmap;

        private var settings:EqualizerSettings;
        private var bars:Array;
        private var reader:SpectrumReader;
        private var effects:EqualizerEffects;

        private var hashTagWidth:uint = 250;

        protected var values:Array = [];
        private var colors:Array = [ 0xff2bb9d1, 0xff36a9c6, 0xff4294b9, 0xff4d82ae, 0xff5278a7,
                                     0xff5d649a, 0xff635892, 0xff6c4a87, 0xff704384, 0xff76347b]

        public function Equalizer(settings:EqualizerSettings = null) {
            if (settings == null) settings = new EqualizerSettings();
            effects = new EqualizerEffects(this);
            update(settings);
        }

        public function update(s:EqualizerSettings, b:Array=null):void {
            settings = s;
            bars = b;
            if (canvas != null && contains(canvasHolder)) {
                removeChild(canvasHolder);
                canvas.dispose();
            }

            reader = new SpectrumReader(settings.numOfBars);

            settings.colorManager.setSettings(settings);

            canvas = new BitmapData(1500, settings.height, true, 0x00000000);
            canvasHolder = new Bitmap(canvas);
            addChild(canvasHolder);

            effects.update(settings);
        }

        public function getSettings():EqualizerSettings {
            return settings;
        }

        public function render(renderSpectrum:Boolean):void {
            canvas.lock();
            var spectrum:Array = reader.getSpectrum();

            var m:int = reader.getSize() / 2;
            var bp:int = settings.barSize; // bar width
            var gs:int = (settings.vgrid && settings.barSize > 1) ? 1 : 0; // grid space
            var i:int; // current bar
            var j:int; // yPositionInBar ---> this whole thing is rotated 90deg
            var b:int; // xPositionInRow ---> this whole thing is rotated 90deg
            var xPos:uint = 0;

            // for each bar we need to create
            for(i = 0; i < reader.getSize(); i++) {

                var weight:uint;
                if(bars)
                    weight = bars[i].weight;
                else
                    weight = 1;

                var value:Number;

                if(renderSpectrum)
                    value = Math.min(settings.height, Math.round(spectrum[i] * settings.height));
                else
                    value = 0;

                var pixel:uint;
                var nbf:Number;
                // j == the max height of the spectrum canvas
                for (j = 0; j < settings.height + hashTagWidth; j++) {
                    pixel = canvas.getPixel32(xPos, j);
                    if (pixel != 0x00000000) {
                        // var myAlpha:uint = pixel >> 24;
                        // var maskedColor:uint = (pixel & 0x00FFFFFF);
                        // var maskedAlpha:uint = (myAlpha & 0xFF000000);

                        // trace("alpha: " + myAlpha.toString(16));
                        // trace("maskedAlpha: " + maskedAlpha.toString(16));
                        // trace("maskedColor: " + maskedColor.toString(16));

                        // loop through each pixel in the row
                        // bar < barWidth - gridSpace

                        // b ==  the width of the bar
                        for (b = 0; b < (bp * weight) - gs; b++) {
                            canvas.setPixel32(xPos + b, j, 0x00000000);
                        }

                        if (settings.hgrid == 0)
                            nbf++;
                        else if (settings.hgrid != 0 && j % settings.hgrid == 0)
                            nbf++;
                    }

                    if (nbf > settings.height / (32 * (settings.hgrid + 1)))
                        break;
                }

                // Rendering new bars
                // j ==  the bar height && value is the height to draw
                //

                if(!values[i]) {
                    values.push([0, 0, 0, 0, 0, 0, 0, 0, 0, 0]);
                }
                else {
                    updateValues(values[i], value);
                    var smoothedNumber:Number = smoothe(values[i]);
                }


                for (j = 0; j < smoothedNumber + hashTagWidth; j++) {
                    if (settings.hgrid != 0 && j % settings.hgrid == 1)
                        continue;
                    if (settings.hgrid != 0 && value / settings.hgrid < 1)
                        break;

                    // b ==  the width of the bar
                    for (b = 0; b < (bp * weight) - gs; b++) {
                        canvas.setPixel32(xPos + b, settings.height - j, colors[weight - 1]);
                    }
                }

                // increment the xPos - since bar widths are varied
                xPos += bp * weight;
            }

            canvas.unlock();
            settings.colorManager.onRendered();
            effects.onRendered();
        }

        protected function smoothe(group:Array):Number {
            var length:uint = group.length;
            var total:uint;
            for(var i:uint=0; i < length; i++) {
                total = total + group[i];
            }

            return total / length as Number;
        }

        protected function updateValues(group:Array, value:Number):void {
            group.shift();
            group.push(value);
        }
    }
}