Analizzatore di spettro in Flash

Il Flash, da solo, non può analizzare in alcun modo lo spettro di un suono.

Il funzionamento dell'analizzatore, si basa su una serie di variabili create da un programma che analizza lo spettro, e ne ricava i picchi. Il flash legge i valori (inseriti in un filmato esterno), e in base a questi setta le dimensioni delle barre. C'è più di un programma in grado di generare queste variabili, ma quello che vediamo è lo Swif-tMP3 (un altro, ad esempio, è il FlashAmp, mentre gli analizzatori di Flashkit sono basati su un cgi prodotto da loro, il cui codice non è libero).

Swift-MP3

Lo Swift-MP3 è un programma della Swift-Tools, e può essere scaricato gratuitamente da questa pagina, dove è disponibile in varie versioni per ogni piattaforma. Il programma può essere utilizzato sia in remoto (come CGI), che in locale, come eseguibile, per creare uno o più filmati (anche in sequenza batch), partendo da semplici file mp3.

L'argomento di questo articolo non è l'uso del programma, ma la creazione dell'analizzatore. Per questo motivo, mi limito a spiegare il funzionamento del programma in locale su Windows (quello in remoto è molto facile, si tratta solo di passare alcune variabili tramite url).

Scarichiamo quindi la versione 2.1 da questo link (46k), e scompattiamo lo zip nella cartella C:swiftmp3 (può essere una cartella qualsiasi, uso questa per semplicità di percorsi). All'interno della cartella, troveremo 4 file:

1. instructions.txt (istruzioni per l'uso del programma, in inglese)
2. license.txt (termini della licenza d'uso)
3. readme.txt (descrizione dei file, modifiche dall'ultima versione)
4. swiftmp3.exe (l'eseguibile che genera i filmati, che può essere rinominato in cgi per l'uso in remoto)

Cliccando sull'eseguibile non succede niente, dal momento che bisogna accedervi tramite linea di comando. Quindi, nei sistemi Windows, dovremo aprire una finestra di "ms dos": andiamo al menu di Avvio, e scegliamo: "Prompt di MS-DOS" in win95/98 e "Prompt dei comandi" in winxp/2k.

Questa è la classica finestra che ci si presenterà davanti:

Potrebbe esserci scritto: C:Documents and Settingsutente ma non ha importanza. Quello che dobbiamo fare, è scrivere in ogni caso: 

in modo da ritrovarci in:

Digitiamo ancora "swiftmp3", e vedremo questa schermata (tagliata per ragioni di spazio):

In questo modo, possiamo vedere le modalità di utilizzo dell'eseguibile.

Innanzitutto, bisogna digitare swiftmp3 (e non swift-mp3, dicitura dovuta probabilmente alle precedenti versioni), poi scrivere le opzioni di creazione del filmato, eventualmente il nome del filmato finale, e il nome del file mp3 da cui partire.

Le opzioni sono:

• fps N, dove N è il frame rate del filmato generato
• spectrum 0:1: scrivendo -spectrum 1 verranno generate le variabili per i picchi
• stop 0:1:2: omettendo questa opzione, il filmato esterno si riprodurrà in streaming al caricamento, scrivendo -stop 1 si fermerà al frame iniziale, scrivendo -stop 2 si fermerà a quello finale
• goto framelabel: con questa opzione, si può rimandare il filmato principale (non quello generato), ad una label specifica quando il filmato esterno è terminato
• out file.swf: si può specificare il nome per il filmato generato. Non scrivendo niente, avrà lo stesso nome dell'mp3 con estensione swf

Il filmato generato, conterrà il suono in streaming, non compresso (quindi con dimensioni uguali o maggiori dell'mp3). Inoltre, per ogni frame, verranno specificati i valori di 18 variabili, i cui nomi sono: s1, s2, s3, s4...s17, e il cui valore varia da 0 a 30.

Le dimensioni dell'swf, vengono quindi determinate dal frame rate (maggiore l'fps, maggiore il numero di variabili, maggiore il peso), in modo comunque non determinante (pochi kb).

(a dire il vero non vengono specificate tutte e 18 in ogni frame, ma solo quelle che cambiano rispetto al frame precedente: quindi se il valore di s13 al frame 23 è uguale a quello del frame 22, nel frame 23 non viene specificato).

Ora, se nel filmato con l'analizzatore noi rileviamo i valori dei picchi 24 volte al secondo (quindi il filmato ha un frame rate di 24 FPS), è inutile settare 36 nel frame rate del filmato esterno, perchè perderemmo alcuni valori. Allo stesso modo, è inutile usare un frame rate di 12, perchè avremmo dei cicli inutili in quello principale. In conclusione, è opportuno settare lo stesso frame rate in entrambi i filmati.

Facciamo un esempio. Copiamo nella cartella C:swiftmp3 il file "mio file.mp3". Non vogliamo mettere degli stop, perchè vogliamo che venga eseguito in ciclo, vogliamo che vengano generate le variabili, e che il frame rate sia 24 FPS. Scriveremo quindi nel prompt:

Nella scrittura dei comandi, bisogna stare molto attenti ai possibili errori, come unire i nomi delle opzioni ai rispettivi valori, o omettere i trattini, o usare spazi nel nome senza le virgolette. In questo caso, al più, verranno generati più filmati, magari vuoti, o senza le variabili.

A questo punto, abbiamo il filmato contenente il suono, senza stop o rimandi a diversi frame, con un frame rate di 24 FPS (con un frame rate minore di 24, l'analizzatore è abbastanza brutto, mancando di fluidità), e fingiamo che si chiami suono.swf: vediamo adesso la costruzione dell'analizzatore.

Innanzitutto, dobbiamo considerare un preloader per il filmato esterno, a meno che non vogliamo riprodurlo in streaming. Quindi, nella prima scena del fla scaricabile, ho inserito un movieclip con il seguente script:

Il codice ferma la riproduzione del filmato principale, carica il filmato esterno sul livello 1, definisce un'istanza dell'oggetto Sound legata al livello1, e ne setta il volume a 0 (non sentiremo il suono fino a che non vorremo).

Quindi, ad ogni riproduzione del movieclip, vengono determinati i valori dei bytes caricati e totali: sulla base di questi, viene riempito un campo di testo che riporterà la percentuale di caricamento, e quando saranno uguali, la testina di riproduzione verrà spostata al frame seguente della timeline principale.

A questo punto, passiamo alla scena principale. Nel primo frame è presente questo script:

con cui fermiamo la riproduzione della timeline principale, settiamo la variabile "stato" come "stop" (già fatto nel preloader, ma utile per altre combinazioni), fermiamo il filmato con il suono nel frame 1, e settiamo il valore del volume di "snd" su 100. Inoltre sono presenti tre pulsanti, play, stop, e pausa.

Play:

Stop:

Pausa:

Il pulsante play, avvia la riproduzione del livello 1, dove è presente il filmato contenente il suono, e setta la variabile "stato" nella root con il valore di "play" (la variabile ci servirà anche più avanti per aggiungere altri pulsanti). Il pulsante stop, ferma il filmato esterno sul primo frame, e setta la variabile "stato" con il valore "stop". Il pulsante pausa, invece, solo quando il filmato esterno è in riproduzione, ne interrompe la riproduzione sul frame presente.

Nella libreria, è presente un movieclip chiamato barra, il cui linkage è "bar". Questo movieclip, contiene un rettangolo nero di dimensioni 4x1, con l'angolo inferiore sinistro sul punto di registrazione. Ci servirà per creare sia le barre, che i picchi.

Nel layer contenitore, è presente un movieclip vuoto, a cui è associato lo script che "crea" l'analizzatore:

Lo script potrebbe essere molto più semplice (basterebbe togliere i riferimenti al colore delle barre e all'accellerazione della caduta dei picchi), ma così è mmolto più completo e personalizzabile.

Innanzitutto, prenderemo solo i primi 14 dei 18 valori che vengono forniti dal filmato creato con lo Swift-MP3: questo perchè gli ultimi 4 rimangono quasi sempre a valori minimi, disturbando quindi l'estetica generale. Su questi 14 valori, ad ogni riproduzione del movieclip allungheremo o accorceremo le 14 barre create con l'attachMovie dal movieclip "barra" nella libreria, e alzeremo e abbasseremo i 14 picchi. Inoltre, coloreremo le barre a seconda della loro lunghezza, considerando un colore iniziale e un colore finale.

Creazione delle barre

Con un ciclo che va da 0 a 13 (14 iterazioni), creiamo due variabili, m e n, che conterranno un riferimento a due diverse serie di movieclip attaccati dentro il movieclip contenitore. Nel primo caso i riferimenti saranno del tipo bar0, bar1, bar2, ...., bar13, nel secondo caso del tipo pic0, pic1, pic2, ...pic13. Con questi nomi, verranno attaccate 28 istanza (14 per ciascuna serie) del movieclip "barra" presente in libreria con il linkage "bar". Posizioniamo i movieclip a coppie (un picco e una barra) alla distanza di 26 pixel dal centro del contenitore, e con una aggiunta del prodotto tra 5 e il valore di i: i movieclip si sposteranno mano mano verso destra, alla distanza di un pixel l'uno dall'altro (5 è lsa distanza, 4 la larghezza del movieclip).

Per ogni elemento della serie di barre, creiamo un'istanza dell'oggetto Color, e riempiamo l'array old, composto da 14 elementi), con il valore attuale del tempo passato dall'inizio del filmato (questi tempi ci serviranno per le cadute dei picchi).

Determinazione dei colori

Consideriamo due colori, uno iniziale e uno finale, e i rispettivi valori RGB. Faremo in modo che partendo da uno dei due, le barre sfumino verso l'altro a seconda della loro lunghezza. Quindi chiamiamo come eR, eG, eB, i tre valori del colore finale, e come sR, sG, sB i tre valori del colore finale (nel nostro caso, un violetto e il bianco).

Dal momento che i valori delle variabili passate dal filmato esterno, vanno da 0 a 30, dividiamo le differenze rispettive tra i tre valori in trenta passi. Queste differenze, che si chiameranno pR, pG, pB, e di cui teniamo il valore assoluto, andranno moltiplicate per il valore estratto dallo spettro.

Ridimensionamento e colorazione delle barre

Con un ciclo che va da 0 a 13, assegniamo a "val" il valore della variabile, presente nel livello 1 (il filmato esterno), con il nome composto dalla stringa "s" più i, quindi, in ciclo, s0, s1, s2 eccetera. Alla variabile "n", come già visto, attribuiremo invece il valore della stringa composta da "bar" più "i", creando quindi il riferimento a bar0, bar1, bar2.

Se il valore della variabile "stato" sulla root è uguale a "play", e quindi il suono è in riproduzione, setteremo l'altezza delle barre sulla base del valore di "val", e i rispettivi colori settando il valore esadecimale derivato dallo spostamento bit a bit dei tre componenti visti prima.

Ad esempio, stabilito che pR è un trentesimo della differenza del valore del rosso tra il bianco e il violetto, lo moltiplichiamo per il valore di "val", e lo sottraiamo a sR.

Nel caso in cui la variabile "stato" sia uguale a "stop", finche l'altezza di ciascuna barra è maggiore di 0, ne diminuiamo il valore di una unità (le barre spariscono quando non c'è suono).

Posizionamento e caduta dei picchi

All'interno dello stesso ciclo visto per le barre, settiamo il riferimento ai picchi con la variabile "m". Se il suono è in riproduzione, se il valore della posizione sull'asse dell y del picco (non vengono ridimensionati, ma spostati) è maggiore del valore di - val, settiamo la posizione su "val", e nell'array "old", sostituiamo l'elemento corrispondente con una nuova rilevazione del tempo dall'inizio del filmato.

Bisogna capire il perchè di questa condizione, che appare alquanto strana. I picchi, all'inizio del filmato, vengono attaccati nel movieclip contenitore, e posizionati sull'asse dell x procedendo gradualmente verso destra. La posizione sull'asse delle Y, invece, non viene settata, e quindi vengono posizionati automaticamente a valore 0.

Ora, dal momento che giacciono in partenza nel centro del movieclip, considerando il sistema cartesiano di flash, in cui il quadrante positivo è quello in basso a destra, i picchi, per muoversi verso l'alto, devono assumere valori negativi.

Quindi, per decidere di spostare verso l'alto un picco, valutiamo se la posizione che dovrà assumere la _y sarà minore di quella attuale, e quindi maggiore di -val.

Il controllo più importante, avviene nella discesa. Se dall'ultima volta in cui il picco è andato verso l'alto, è passato un secondo, il picco inizia a scendere, accellerando verso il basso.

Questa, infatti, è la formula per il moto accellerato, considerando come posizione finale lo 0:

mentre quella per il moto decelerato sarebbe:

Quindi, il ciclo si svolge così:

• "val" è maggiore del valore attuale della posizione del picco, allora alzo il picco e azzero il tempo
• se è passato un secondo, e in questo secondo il picco non si è alzato, lo abbasso

Se invece interrompiamo la riproduzione del suono, e quindi "stato" diventa ugaule a "stop", allora valutiamo nuovamente la posizione del picco.

Se il valore assoluto della posizione del picco (in positivo o in negativo, appunto), è maggiore di 0.5, allora diminuiamo la posizione di una unità. Se invce è minore di 0.5, posizioniamo il picco con _y uguale a 0. Questo serve ad evitare che durante la discesa, il picco scenda sotto lo zero.

In tutti i casi abbiamo considerato il valore di "stato" uguale a "play" o a "stop". Questo perchè, quando premiamo il pulsante "pausa", i picchi e le barre rimangano fermi nella posizione, colore e dimensioni attuali.