Forked from:: Thy's .mp3 player (spectrum)

sound spectrum ring (with FFT)

guyz, i dont really know if I can use those musics. They are not mine..
please warn me if i shold use those .mp3, and, if possible, where's an .mp3 a cold use :D thx

Thy

forked:1
favorite:1
lines:444
license : MIT License
modified : 2010-08-27 01:25:27

Embed: Tweet

// forked from Thy's .mp3 player (spectrum)
// forked from Thy's .mp3 player
// guyz, i dont really know if I can use those musics. They are not mine..
// please warn me if i shold use those .mp3, and, if possible, where's an .mp3 a cold use :D thx
package 
{
    import flash.text.TextField;
    import flash.filters.DropShadowFilter;
    import flash.display.Graphics;
    import flash.display.Sprite;
    import flash.events.Event;
    import flash.events.MouseEvent;
    /**
     * ...
     * @author Thi
     * v. 1.5
     *     
     * simple usa of the class:
     * There are .mp3's in websites. They can be mine (like, from webs.com)
     * or they can be not mine (like, search on bee.mp3)
     * if the site is mine, i can get the ID3 and stuff by an local .swf, Entrosa
     * else, i pretend to get it (but i wont), using an defalt EntrosaPlacebo
     *
     * sry, it still brazilian
     *
     */
    public class Main extends Sprite 
    {
        // layer
        private var
        layer3:Sprite = new Sprite(); // buttons
        
        // music
        private var 
        player:MusicPlayer;
        
        // spectrum
        private var espectro:Espectro = new Espectro(20, 3)
        
        // temp
        private var
        sprite:Sprite,
        g:Graphics;
        
        public function Main():void 
        {
            if (stage) init();
            else addEventListener(Event.ADDED_TO_STAGE, init);
        }
        
        private function init(e:Event = null):void 
        {
            removeEventListener(Event.ADDED_TO_STAGE, init);
            this.x = 8; this.y = 140 // for wonderfl print screen
            // layers
            addChild(layer3)
            
            // music
            var links:Array = 
            [ 
            "http://thymusic.webs.com/Entrosa8.swf",
            "http://thymusic.webs.com/m/06%20Eminem%20Feat%20Rihanna%20-%20Love%20The%20Way%20You%20Lie.mp3",
            "http://thymusic.webs.com/m/13%20David%20Guetta%20&%20Chris%20Willis%20Feat%20Fergie%20&%20Lmfao%20-%20Gettin%20Over%20You.mp3",
                
            "http://thymusic.webs.com/EntrosaPlacebo6.swf",
            "http://phoenix.vlcteam.free.fr/Son/Bourrier/02 - Helicopter.mp3",
            "http://aolradio.podcast.aol.com/aolmusic/mp3s/Nirvana_AboutAGirl.mp3",
            
            "http://thethi.webs.com/Entrosa8.swf",
            "http://thethi.webs.com/m/Im%20Not%20Alone_.mp3",
            "http://thethi.webs.com/m/39%20Glee%20Cast%20-%20It's%20My%20Life-Confessions%20Pt.II.mp3"
            ]
            
            player = new MusicPlayer( this, links , null, false)
            
            var nomes:Array = 
            [
            true, // sempre quando a próxima "" for um entrosa, vc coloca o 'nome do álbum'
            "Pop",
            "LALALALA, this music I can reach the ID3, so this is not necessari", // esse nome tbm já é acesível pelo ID3
            "This one too, i can get the ID3", // esse nome já é acessível pelo ID3
            true,
            "Diversas",
            "Helicopter - Bloc Party", // this one i CANT get the ID3
            "About A Girl - Nirvana", // this neigther
            true, // agr vai ser umas que têm um entrosa no msm domínio, ou seja, os ID3 SÃO acessíveis
            "Outras", // então, se os ID3 são acessíveis, a classe, na hora de colocar um nome, só vai usar esses se o ID3 não foi acessível ^^
            "This wold be 'Im Not Alone' but it will look for the original ID3", // então pode escrever o que quiser, que o ID3 verdadeiro será mostrado
            "Blablabla, saiduhasoiduask, sería a glee - its my life" // então, nem precisa escrever (escreve null se o ID3 já for acessível)
            ]
            // manda a 'nomes' da classe ser igual à, no meu caso, a var nomes
            // então .formarNomes() organiza os nomes, da classe
            player.nomes = nomes
            player.formarNomes();
            
            // spectrum
            var sprite:Sprite = new Sprite;
            addChild(sprite); sprite.addChild(espectro);
            espectro.x = 465/2; espectro.y = 100;
            sprite.filters = [new DropShadowFilter(4,45,0,1,4,4,1,1,false, true)]
            
            // player start
            player.start();
            
            // listener
            stage.addEventListener(Event.ENTER_FRAME, ef);
        }
        
        private function ef (e:Event):void
        {
            if (!player._play) { player.play() }
            // se informações como id3 já foram puxadas, é um sinal de que o espectro já poderá ser calculado
            if(player.id3Pego)
            {
                // método que pega o espectro
                player.objEntrosa.getByteArray()
                // guarda o espectro que foi pêgo em alguma var, NO ESPECTRO
                // agente nem precisa criar um ba aqui no .fla
                espectro.ba = player.objEntrosa.ba
                // agora desenha o espectro:
                espectro.refresh()
            }
        }
    }
}

//package  
//{
    import flash.display.Shape;
    import flash.display.Graphics;
    import flash.utils.ByteArray;
    /**
     * ...
     * @author Thi
     * v. 1.0
     */
    /*public*/ class Espectro extends Shape
    {
        // o tipo do espectro
        public var tipo:int
        // a ba do espectro
        public var ba:ByteArray
        // a altura do espectro
        public var altura:Number
        
        // var de referência, pra ter que escrever menos..
        private var g:Graphics
        
        public function Espectro(altura:Number = 1, tipo:int = 0) 
        {
            // setup
            this.altura = altura
            this.tipo = tipo
            g = this.graphics
        }
        
        // variáveis usadas nos desenhos do spec
        private var i:int
        private var step:Number, ang:Number, alcance:Number
        
        public function refresh():void
        {
            g.clear()
            if(!ba) return;
            g.lineStyle(1,0)
            // loops
            var i:int
            //
            switch(tipo)
            {
                case 0: // linha (256)
                i = 0
                g.moveTo(0, (1 - ba.readFloat()) * altura)
                while(++i < 256) g.lineTo(i, (1 - ba.readFloat()) * altura)
                break;
                
                case 1: // linha dupla (512)
                i = 0
                g.moveTo(0, (1 - ba.readFloat()) * altura*.5)
                while(++i < 256) g.lineTo(i, (1 - ba.readFloat()) * altura*.5)
                i = 0
                g.moveTo(0, altura*.5)
                while(++i < 256) g.lineTo(i, altura*.5 + ba.readFloat() * altura*.5)
                break;
                
                case 2: // bola (256)
                i = 0
                step = 360 * Math.PI / (256 * 180), ang = 0, alcance = 0
                g.moveTo(-Math.cos(ang)*(alcance = altura*.75* ba.readFloat() + altura*.25), -Math.sin(ang)*alcance)
                while(++i < 256) g.lineTo(-Math.cos((ang += step))*(alcance = altura*.75* ba.readFloat() + altura*.25), -Math.sin(ang)*alcance)
                break;
                
                case 3: // bola dupla (512)
                i = 0
                step = Math.PI / 256, ang = 0, alcance = 0
                g.moveTo(-Math.cos(ang)*(alcance = altura*.75* ba.readFloat() + altura*.25), -Math.sin(ang)*alcance)
                while(++i < 256) g.lineTo(-Math.cos((ang += step))*(alcance = altura*.75* ba.readFloat() + altura*.25), -Math.sin(ang)*alcance)
                i = ang = 0
                g.moveTo(-Math.cos(ang)*(alcance = altura*.75* ba.readFloat() + altura*.25), -Math.sin(ang)*alcance)
                while(++i < 256) g.lineTo(-Math.cos((ang -= step))*(alcance = altura*.75* ba.readFloat() + altura*.25), -Math.sin(ang)*alcance)
                break;
                
                case 4: // bola interna (256)
                i = 0
                step = 360 * Math.PI / (256 * 180), ang = 0, alcance = 0
                g.moveTo(-Math.cos(ang)*(alcance = ((1 - ba.readFloat())*altura)), -Math.sin(ang)*alcance)
                while(++i < 256) g.lineTo(-Math.cos((ang += step))*(alcance = ((1-ba.readFloat())*altura)), -Math.sin(ang)*alcance)
                break;
                
                case 5: // bola interna (512)
                i = 0
                step = Math.PI / 256, ang = 0, alcance = 0
                g.moveTo(-Math.cos(ang)*(alcance = ((1 - ba.readFloat())*altura)), -Math.sin(ang)*alcance)
                while(++i < 256) g.lineTo(-Math.cos((ang += step))*(alcance = ((1-ba.readFloat())*altura)), -Math.sin(ang)*alcance)
                i = ang = 0
                g.moveTo(-Math.cos(ang)*(alcance = ((1 - ba.readFloat())*altura)), -Math.sin(ang)*alcance)
                while(++i < 256) g.lineTo(-Math.cos((ang -= step))*(alcance = ((1-ba.readFloat())*altura)), -Math.sin(ang)*alcance)
                break;
                
                
                
            }
        }
        
    }

//}

//package  
//{
    import flash.display.Graphics;
    import flash.display.Loader;
    import flash.display.MovieClip;
    import flash.display.Sprite;
    import flash.events.Event;
    import flash.events.MouseEvent;
    import flash.events.ProgressEvent;
    import flash.media.Sound;
    import flash.media.SoundChannel;
    import flash.media.SoundTransform;
    import flash.net.URLRequest;
    import flash.text.TextField;
    import flash.text.TextFieldAutoSize;
    import flash.text.TextFormat;
    import flash.utils.ByteArray;
    /**
     * ...
     * @author Thi
     */
    /*public*/ class MusicPlayer extends Sprite
    {
        // variáveis setup
        public var links:Array // os links
        public var nomes:Array // os nomes das músicas
        
        // as variáveis que poderão ser retornadas
        public var string:String // palavra que o 'texto' mostrará (status ou informações)
        public var loading:Number // carregamento das musicas à ser tocada, 0 ~ 1
        public var length:Number // a estimativa da duração total da música, em milisegundos
        public var playing:Number // a estimativa do tanto da música que já foi tocado, 0 ~ 1
        public var objEntrosa:Object // variável acessível do .fla, o Entrosa
        public var id3Pego:Boolean // variável acessível do .fla, pra ver se o ID3 foi carregado
        // quando o ID3 da música é carregado, pode-se dar play, pegar o ID3, pegar espectro
        
        private var st:Sprite
        
        private var i:int, j:int, k:int // temp int
        private var s:String // temp string
        
        public function MusicPlayer(st:Sprite = null, links:Array = null, nomes:Array = null, mouseStart:Boolean = true) 
        {
            // setup
            this.st = st
            this.links = links
            this.nomes = nomes
            //
            
            formarLinks()
            //
            somC.soundTransform = somT
            //
            
            if (mouseStart)
            {
                
                st.addEventListener(MouseEvent.MOUSE_MOVE, init);
            }
        }
        
        public function formarLinks():void
        {
            var links2:Array = []
            i = -1
            while (++i < links.length)
            {
                links2[i] = links[i].concat()
            }
            links = []
            //
            // organiza melhor a indexação dos links
            i = 0; k = -1
            j = links2.length
            while (i < j)
            {
                s = links2[i]
                if (s.charAt(s.length - 3) == "s" && s.charAt(s.length - 2) == "w" && s.charAt(s.length - 1) == "f")
                {
                    // adiciona um novo entrosa
                    links.push([s])
                    ++k
                } else
                {
                    // se tiver alguma coisa escrito
                    if (s != "")
                    {
                        // adiciona uma nova música
                        links[k].push(s)
                    }
                }
                ++i
            }
            links2 = null
            
        }
        
        public function formarNomes():void
        {            
            var nomes2:Array = []
            i = -1
            while (++i < nomes.length)
            {
                nomes2[i] = nomes[i]
            }
            nomes = []
            // organiza os nomes (ID3 pré-determinado)
            i = -1, k = -1, j = nomes2.length
            while (++i < j)
            {
                s = String(nomes2[i])
                if (s == "true")
                {
                    // adiciona uma nova categoria
                    nomes.push([String(nomes2[++i])])
                    ++k
                } else
                {
                    // se tiver alguma coisa escrito
                    if (s != "")
                    {
                        // adiciona uma nova música
                        nomes[k].push(s)
                    }
                }
            }
            
        }
        
        private function init(e:MouseEvent):void
        {
            st.removeEventListener(MouseEvent.MOUSE_MOVE, init)
            start()
            st = null
        }
        
        public function start():void
        {
            // a 1° musica
            link_entrosa = links[0][0]
            track = 1
            // faz o loader
            loader()
        }
        
        private var link_entrosa:String
        private var carregou:Boolean
        private var Entrosa:Loader
        private function loader():void
        {
            // carrega o Entrosa. É ele quem na verdade manda carregar as musicas
            string = "Carregando álbum"
            Entrosa = new Loader()
            Entrosa.load(new URLRequest(link_entrosa))
            //Entrosa.contentLoaderInfo.addEventListener(ProgressEvent.PROGRESS, loader_progress)
            Entrosa.contentLoaderInfo.addEventListener(Event.COMPLETE, loader_complete)
        }
        
        
        private function loader_complete(e:Event):void
        {
            // novo entrosa carregado
            string = "Álbum carregado"
            Entrosa.contentLoaderInfo.removeEventListener(Event.COMPLETE, loader_complete)
            objEntrosa = Object(Entrosa.content)
            // carrega nova musica
            newMusic()
        }
        
        private var som:Sound // a var Som, só tem uma
        private var somC:SoundChannel = new SoundChannel() // channel, posso dar pause etc
        private var somT:SoundTransform = new SoundTransform() // posso mudar o volume
        public var track:int = 0 // o index da musica à ser tocada
        
        // em qual Entrosa está a musica que está sendo tocada
        public var album:int
        
        private function newMusic():void
        {
            // arruma algumas variáveis
            carregou = false
            position = 0 // posição do play
            id3Pego = false
            tentativas = 0 // número de tentativas pra pegar o ID3 da música
            
            // arruma a música à ser tocada. É complicado porquê pode-se ter vários entrosas
            // o que considerei por 'vários álbuns'
            if (track >= links[album].length)
            {
                ++album
                if (album >= links.length)
                {
                    album = 0
                }
                track = 1
                // álbum posterior, carrega-se o novo Entrosa
                link_entrosa = links[album][0]
                loader()
            } else if (track < 1)
            {
                --album
                if (album < 0)
                {
                    album = links.length-1
                }
                track = links[album].length-1
                // álbum anterior, carrega-se o novo Entrosa
                link_entrosa = links[album][0]
                loader()
            } else 
            {
                // se não precisou trocar de álbum, é porquê não precisa carregar o novo entrosa
                newMusic2() // então continua na criação da musica
            }
        }
        
        public function changeMusic(album:int = 0, track:int = 1):void
        {
            if ((this.track != track || this.album != album) && pode_apertar)
            {
                pode_apertar = false // será true qdo o ID3 ficar pronto
                this.removeEventListener(Event.ENTER_FRAME, ef)
                somC.stop() // para o som atual
                if (!carregou)
                {
                    // se o som não estiver 100% carregado, fecha o stream
                    som.close()
                }
                
                
                this.track = track
                if (this.album != album)
                {
                    this.album = album
                    link_entrosa = links[album][0]
                    loader()
                } else 
                {
                    newMusic()
                }
            }
        }
        
        private function newMusic2():void
        {
            // vê o link da musica mp3
            objEntrosa.link = links[album][track]
            objEntrosa.loadLink() // manda o entrosa carregar o link enviado
            
            // lá no Entrosa tem uma var som. O nosso som daqui será uma referência à ela
            som = null
            som = objEntrosa.som 
            
            // listeners
            som.addEventListener(Event.COMPLETE, Lcomp) // acabou de carregar musica
            som.addEventListener(ProgressEvent.PROGRESS, Lprog) // carregando musica
            this.addEventListener(Event.ENTER_FRAME, id3) // pegando o ID3 da musica
            string = "Carregando música"
        }
        
        private function Lcomp(e:Event):void
        {
            // música totalmente carregada
            som.removeEventListener(Event.COMPLETE, Lcomp)
            som.removeEventListener(ProgressEvent.PROGRESS, Lprog)
            carregou = true
            // vê o valor do loading da música. Pode-se acessar essa var pelo .fla
            loading = 1 // 1 = 100%
            length = som.length // length real
        }
        
        private function Lprog(e:ProgressEvent):void
        {
            // vê o valor do loading da música. Pode-se acessar essa var pelo .fla
            loading = e.bytesLoaded / e.bytesTotal // 0 ~ 1
            length = som.length / loading // em milisegundos
        }
        
        private var tentativas:int // tentativas pra pegar o ID3
        private function id3(e:Event = null):void
        {
            if (objEntrosa.id3Pronto && !id3Pego)
            {
                if(objEntrosa.id3)
                {
                    string = (objEntrosa.id3.songName == null ? "Música desconhecida" : objEntrosa.id3.songName) + " - "  + (objEntrosa.id3.artist == null ? "Artista desconhecido" : objEntrosa.id3.artist)
                } else 
                if (nomes != null)
                {
                    if (nomes[album][track] != undefined)
                    {
                        string = nomes[album][track]
                    } else
                    {
                        string = "Nome da Música e Artista Inacessíveis"
                    }
                } else
                {
                    string = "Nome da Música e Artista Inacessíveis"
                }
                if(string == "Música desconhecida - Artista desconhecido")
                {
                    string = "Música e Artista desconhecidos"
                }
                
                id3Pego = true
                
                if (_play)
                {
                    somC = som.play()
                }
                
                pode_apertar = true
                this.addEventListener(Event.ENTER_FRAME, ef)
                
                //remove o listener desta função
                this.removeEventListener(Event.ENTER_FRAME, id3)
            }  else if (loading > 3 && ++tentativas > stage.frameRate+2) 
            {
                // desiste de pegar o ID3, então finge-se que o pegou, para os processos continuarem
                objEntrosa.id3Pronto = true
            }
        }
        
        public var _play:Boolean // pode-se ver se está tocando ou não
        public var pode_apertar:Boolean
        
        public var position:Number = 0
        public function pause(pos:Boolean = true):void
        {
            if (_play && pode_apertar)
            {
                _play = false
                if (pos)
                {
                    position = somC.position // guarda a posição
                } else
                {
                    position = 0 // reseta a posição
                }
                somC.stop()
            } else if (!pos && pode_apertar)
            {
                position = 0
            }
        }
        
        public function play():void
        {
            if (!_play && pode_apertar)
            {
                _play = true
                somC = som.play(position) // dá play no som, dependendo da posição
            }
        }
        
        public function volume(volume:Number = 0):void
        {
            if (somT.volume != volume)
            {
                somT.volume = volume
                somC.soundTransform = somT
            }
        }
        
        private function ef(e:Event):void
        {
            if(_play)
            {
                // calcula aposição do 'playing' (0 ~ 1)
                playing = somC.position / length
                // se a música acabar, vai pra próxima
                if (playing >= .99)
                {
                    this.removeEventListener(Event.ENTER_FRAME, ef)
                    // vai pro 'next', como se tivesse clicado no botão
                    changeMusic(album, track + 1)
                }
            }
        }
        
    }

//}

Code Fullscreen

Preview Fullscreen