forked from: forked from: 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
...
@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
/**
* Copyright Thy ( http://wonderfl.net/user/Thy )
* MIT License ( http://www.opensource.org/licenses/mit-license.php )
* Downloaded from: http://wonderfl.net/c/phdj
*/
// forked from bradsedito's forked from: sound spectrum ring (with FFT)
// forked from Thy's sound spectrum ring (with FFT)
// 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(465*.5, 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)]
////// EDIT by BradSedito
// this.width = 300;
// this.height = 300;
// sprite.x += mouseX;
// sprite.y += mouseY;
// this.scaleX = 6;
// this.scaleY= 6;
// 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)
}
}
}
}
//}