ERYSTREAMING V2.05 CS4 AS3

package
{
	import flash.display.MovieClip;
	import flash.display.Sprite;
	import flash.events.*;
	import flash.net.URLLoader;
	import flash.net.URLRequest;
	import flash.net.NetConnection;
	import flash.net.NetStream;
	import flash.utils.Timer;
	import flash.media.Sound;
	import flash.media.SoundLoaderContext;
	import flash.media.SoundTransform;
	import flash.media.SoundChannel;
	import flash.ui.Keyboard; 
	
	public class erystreaming extends MovieClip
	{
		const INFOMANIAK		:String = new String("http://<station>.ice.infomaniak.ch.ice.infomaniak.ch/meta.xsl?mount=/<station>-high.mp3");
		const STATSLIVE			:String = new String("http://statslive.infomaniak.ch/player/xml/");
		const BROADCAST			:String = new String("http://broadcast.infomaniak.ch/player/");
		const VERIFAAC			:String = new String("http://statslive.infomaniak.ch/player/xml/verifAAC.php?fic=");
		const SHOUTCAST			:String = new String("http://yp.shoutcast.com/sbin/tunein-station.pls?id=");
		const PHP_SHOUTCAST		:String = new String("http://yp.shoutcast.com/Metadata_Info1.php");
		const PROXY_STREAMING	        :String = new String("http://www.erysoft.fr/test/erystreaming/streaxy.php");
		const LISTE_INFOMANIAK	        :String = new String("http://www.erysoft.fr/test/erystreaming/station_1.xml");
		const LISTE_SHOUTCAST	        :String = new String("http://www.erysoft.fr/test/erystreaming/station_2.xml");
		const ESPACE			:String = new String("                                            ");
		const MODE_INFOMANIAK	        :int = 1;
		const MODE_URL			:int = 2;
		const MODE_SHOUTCAST	        :int = 3;
		const FENETRE_SAISIE	        :fenetre_saisie_flux = new fenetre_saisie_flux;
		
		var liste_station		:Array;

		var parametre			:Object = loaderInfo.parameters;
		
		var parametre_station	        :String = parametre.sta;
		var parametre_volume	        :String = parametre.vol;
		var parametre_nom		:String = parametre.nom;
		var parametre_auto		:String = parametre.aut;
		var parametre_proxy		:String = parametre.pro;
		var parametre_liste_1	        :String = parametre.lis1;
		var parametre_liste_2	        :String = parametre.lis2;

		var timer_flux			:Timer;
		var timer_affichage		:Timer;
		var son_flux			:Sound;
		var canal_flux			:SoundChannel;
		var effet_flux			:SoundTransform;
		var connexion_reseau	        :NetConnection;
		var flux_audio			:NetStream;

		var flux_mp3_haut		:String;
		var flux_mp3_bas		:String;
		var nom_station			:String;
		var serveur_rtmp		:String; 
		var repertoire_rtmp		:String;
		var flux_rtmp_haut		:String;
		var flux_rtmp_bas		:String;
		var test_rtmp_haut		:String;
		var test_rtmp_bas		:String;
		var domaine_station		:String;
		var flux_courant		:String;
		var titre_musique		:String;
		var artiste_musique		:String;
		var status_connexion	        :String = "ERYSTREAMING V2.05";
		var racine_rtmp			:String;
		var texte_defilant		:String;
		var station_texte		:String;
		var memoire_texte		:String;
		
		var volume_streaming	        :Number;
		
		var pointeur_station	        :int = 0;
		var pointeur_flux		:int = 0;
		var mode_streaming		:int = 0;
		var compteur_barre		:int = 0;
		var rotation_affichage	        :int = 0;
		var numero_liste		:int = 0;
		var compteur_defilement	        :int = 0;

		var debug_xml			:Boolean = false;
		var test_acc_haut_bas	        :Boolean;
		var etat_aac			:Boolean = false;
		var etat_marche			:Boolean = false;
		var modification_volume	        :Boolean = false;
		var etat_proxy			:Boolean = true;
		var une_fois			:Boolean = false;
		var etat_cache			:Boolean = true;
		var etat_meta			:Boolean = false;
		var operation_en_cours	        :Boolean = false;
		
		public function erystreaming():void
		{
			if (parametre_proxy == null) parametre_proxy = PROXY_STREAMING;
			if (parametre_liste_1 == null) parametre_liste_1 = LISTE_INFOMANIAK;
			if (parametre_liste_2 == null) parametre_liste_2 = LISTE_SHOUTCAST;
			chargement_liste_xml(parametre_liste_1);
			numero_liste = 1;
			if (parametre_volume == null) volume_streaming = 0.75;
			else volume_streaming = int(parametre_volume) / 100
			lecteur.bouton_volume.x = 23 + 82 * volume_streaming;
			this.lecteur.bouton_play.addEventListener(MouseEvent.CLICK, action_bouton_play);
			this.lecteur.bouton_stop.addEventListener(MouseEvent.CLICK, action_bouton_stop);
			this.lecteur.bouton_station_plus.addEventListener(MouseEvent.CLICK, action_bouton_station_plus);
			this.lecteur.bouton_station_moins.addEventListener(MouseEvent.CLICK, action_bouton_station_moins);
			this.lecteur.bouton_saisie_flux.addEventListener(MouseEvent.CLICK, action_bouton_saisie_flux);
			this.lecteur.bouton_flux.addEventListener(MouseEvent.CLICK, action_bouton_flux);
			this.lecteur.bouton_selection_station.addEventListener(MouseEvent.CLICK, action_bouton_selection_station);
			this.lecteur.bouton_volume.addEventListener(MouseEvent.MOUSE_DOWN, action_bouton_volume_down);
			this.lecteur.bouton_volume.addEventListener(MouseEvent.MOUSE_OUT, action_bouton_volume_up);
			this.lecteur.bouton_volume.addEventListener(MouseEvent.MOUSE_UP, action_bouton_volume_up);
			this.lecteur.bouton_volume.addEventListener(MouseEvent.MOUSE_MOVE, action_bouton_volume_move);
			lecteur.bouton_volume.buttonMode = true;
			lecteur.bouton_selection_station.visible = false;
			lecteur.bouton_flux.visible = false;
			eteindre_voyant_controle();
			initialisation_bargraph();
			timer_affichage = new Timer(10);
			timer_affichage.addEventListener(TimerEvent.TIMER, action_timer_affichage);
			timer_affichage.start();
			timer_flux = new Timer(10);
			timer_flux.addEventListener(TimerEvent.TIMER, action_timer_flux);
			if (!etat_proxy) lecteur.voyant_proxy.visible = false;
			else lecteur.voyant_proxy.visible = true;
			if (parametre_auto) action_bouton_play(null);
		}
		private function lecture_information_station():void
		{
			eteindre_voyant_controle();
			if (!etat_proxy) lecteur.voyant_proxy.visible = false;
			else lecteur.voyant_proxy.visible = true;
			status_connexion = "CONNEXION EN COURS";
			if (parametre_station.indexOf("|") != -1)
			{
				mode_streaming = MODE_SHOUTCAST;
				lecteur.bouton_flux.visible = false;
				var tableau:Array = parametre_station.split("|");
				etat_aac = false;
				if (tableau[2] == "AAC") etat_aac = true;
				if (etat_proxy) chargement_fichier_pls_proxy(parametre_proxy, tableau[0]);
				else chargement_fichier_pls(SHOUTCAST + tableau[0]);
			}
			else if (parametre_station.indexOf("http://") != -1)
			{
				mode_streaming = MODE_URL;
				flux_courant = parametre_station;
				ouverture_flux_mp3();
				station_texte = parametre_station;
			}
			else
			{
				mode_streaming = MODE_INFOMANIAK;
				lecteur.bouton_flux.visible = true;
				var adresse:String;
				if (debug_xml) adresse = STATSLIVE;
				else adresse = BROADCAST;
				adresse += "configuration_" + parametre_station + ".xml?time=" + new Date().getTime();
				trace("- Xml : " + adresse);
				chargement_fichier_xml(adresse);
			}
		}
		private function chargement_liste_xml(url_liste:String):void
		{
			var chargeur_xml:URLLoader = new URLLoader(new URLRequest(url_liste));
			chargeur_xml.addEventListener(Event.COMPLETE, fin_chargement_liste_xml);
			chargeur_xml.addEventListener(IOErrorEvent.IO_ERROR, gestion_erreur_chargement);
			chargeur_xml.addEventListener(SecurityErrorEvent.SECURITY_ERROR, gestion_erreur_securite);
		}
		private function chargement_fichier_pls(url_pls:String):void
		{
			var chargeur_pls:URLLoader = new URLLoader(new URLRequest(url_pls + "&file=filename.pls"));
			chargeur_pls.addEventListener(Event.COMPLETE, fin_chargement_pls);
			chargeur_pls.addEventListener(IOErrorEvent.IO_ERROR, gestion_erreur_chargement);
			chargeur_pls.addEventListener(SecurityErrorEvent.SECURITY_ERROR, gestion_erreur_securite);
		}
		private function chargement_fichier_pls_proxy(url_proxy:String, parametre:String):void
		{
			parametre += "&time=" + new Date().getTime();
			var chargeur_pls:URLLoader = new URLLoader(new URLRequest(url_proxy + "?hdr=0&opt=pls&par=" + parametre));
			chargeur_pls.addEventListener(Event.COMPLETE, fin_chargement_pls);
			chargeur_pls.addEventListener(IOErrorEvent.IO_ERROR, gestion_erreur_chargement);
			chargeur_pls.addEventListener(SecurityErrorEvent.SECURITY_ERROR, gestion_erreur_securite);
		}
		private function chargement_fichier_meta(url_meta:String):void
		{
			var chargeur_meta:URLLoader = new URLLoader(new URLRequest(url_meta + "?surl=" + flux_courant));
			chargeur_meta.addEventListener(Event.COMPLETE, fin_chargement_meta);
			chargeur_meta.addEventListener(IOErrorEvent.IO_ERROR, gestion_erreur_chargement);
			chargeur_meta.addEventListener(SecurityErrorEvent.SECURITY_ERROR, gestion_erreur_securite);
		}
		private function chargement_fichier_meta_proxy(url_proxy:String):void
		{
			var parametre:String  = flux_courant.substring(7, flux_courant.length) + "&time=" + new Date().getTime();
			var chargeur_meta:URLLoader = new URLLoader(new URLRequest(url_proxy + "?hdr=0&opt=meta&par=" + parametre));
			chargeur_meta.addEventListener(Event.COMPLETE, fin_chargement_meta);
			chargeur_meta.addEventListener(IOErrorEvent.IO_ERROR, gestion_erreur_chargement);
			chargeur_meta.addEventListener(SecurityErrorEvent.SECURITY_ERROR, gestion_erreur_securite);
		}
		private function chargement_fichier_xls(url_xls:String):void
		{
			var parametre:String  = "&time=" + new Date().getTime();
			var chargeur_xls:URLLoader = new URLLoader(new URLRequest(url_xls.replace(/<station>/gi, domaine_station) + parametre));
			chargeur_xls.addEventListener(Event.COMPLETE, fin_chargement_fichier_xls);
			chargeur_xls.addEventListener(IOErrorEvent.IO_ERROR, gestion_erreur_chargement);
			chargeur_xls.addEventListener(SecurityErrorEvent.SECURITY_ERROR, gestion_erreur_securite);
		}
		private function chargement_fichier_xml(url_xml:String):void
		{
			var chargeur_xml:URLLoader = new URLLoader(new URLRequest(url_xml));
			chargeur_xml.addEventListener(Event.COMPLETE, fin_chargement_fichier_xml);
			chargeur_xml.addEventListener(IOErrorEvent.IO_ERROR, gestion_erreur_chargement);
			chargeur_xml.addEventListener(SecurityErrorEvent.SECURITY_ERROR, gestion_erreur_securite);
		}
		private function chargement_rtmp_information(url_rtmp_info:String):void
		{
			var chargeur_rtmp:URLLoader = new URLLoader(new URLRequest(url_rtmp_info));
			chargeur_rtmp.addEventListener(Event.COMPLETE, fin_chargement_rtmp);
			chargeur_rtmp.addEventListener(IOErrorEvent.IO_ERROR, gestion_erreur_chargement);
			chargeur_rtmp.addEventListener(SecurityErrorEvent.SECURITY_ERROR, gestion_erreur_securite);
		}
		private function preparation_lecteur():void
		{
			station_texte = controle_texte_affichage(nom_station);
			if (flux_mp3_haut != null) flux_mp3_haut = "http://" + domaine_station + ".ice.infomaniak.ch" + flux_mp3_haut;
			if (flux_mp3_bas != null) flux_mp3_bas = "http://" + domaine_station + ".ice.infomaniak.ch" + flux_mp3_bas;
			if (flux_rtmp_haut != null) test_rtmp_haut = VERIFAAC + flux_rtmp_haut;
			if (flux_rtmp_bas != null) test_rtmp_bas = VERIFAAC + flux_rtmp_bas;
			racine_rtmp = serveur_rtmp + "/" + repertoire_rtmp;
			trace("- Flux mp3 haut  : " + flux_mp3_haut);
			trace("- Flux mp3 bas   : " + flux_mp3_bas);
			trace("- Flux Rtmp haut : " + flux_rtmp_haut);
			trace("- Flux Rtmp bas  : " + flux_rtmp_bas);
			trace("- Test Rtmp haut : " + test_rtmp_haut);
			trace("- Test Rtmp bas  : " + test_rtmp_bas);
			trace("- Racine Rtmp    : " + racine_rtmp);
			test_acc_haut_bas = true;
			if (test_rtmp_haut != null) chargement_rtmp_information(test_rtmp_haut);
			else lancer_lecteur(null, null);
		}
		private function lancer_lecteur(comment:String, debit:String):void
		{
			if (etat_marche) return;
			initialisation_bargraph();
			eteindre_voyant_controle();
			etat_aac = false;
			operation_en_cours = true;
			if (comment == null)
			{
				if (flux_rtmp_haut != null)
				{
					flux_courant = flux_rtmp_haut;
					initialisation_connexion(racine_rtmp);
					lecteur.texte_flux.text = "AAC-H";
					pointeur_flux = 2;
				}
				else
				{
					flux_courant = flux_mp3_haut;
					ouverture_flux_mp3();
					lecteur.texte_flux.text = "MP3-H";
					pointeur_flux = 0;
				}
			}
			else if (comment == "IDEM")
			{
				if (flux_courant.toLowerCase().indexOf(".aac",0) != -1) initialisation_connexion(racine_rtmp);
				else ouverture_flux_mp3();
			}
			else if (comment == "AAC")
			{
				if (debit == "H")
				{
					flux_courant = flux_rtmp_haut;
					lecteur.texte_flux.text = "AAC-H";
				}
				else
				{
					flux_courant = flux_rtmp_bas;
					lecteur.texte_flux.text = "AAC-L";
				}
				if (flux_courant != null) initialisation_connexion(racine_rtmp);
				else lecteur.texte_flux.text = "---";
			}
			else if (comment == "MP3")
			{
				if (debit == "H")
				{
					flux_courant = flux_mp3_haut;
					lecteur.texte_flux.text = "MP3-H";
				}
				else
				{
					flux_courant = flux_mp3_bas;
					lecteur.texte_flux.text = "MP3-L";
				}
				if (flux_courant != null) ouverture_flux_mp3();
				else lecteur.texte_flux.text = "---";
			}
			else lecteur.texte_flux.text = "---";
		}
		private function arret_lecteur():void
		{
			initialisation_bargraph();
			etat_marche = false;
			etat_meta = false;
			operation_en_cours = false;
			if (etat_aac)
			{
				try {flux_audio.close();}
				catch(e:Error) {}
			}
			else
			{
				try
				{
					son_flux.close();
					canal_flux.stop();
				}
				catch(e:Error) {}
			}
			try {timer_flux.stop();}
			catch(e:Error) {}
			status_connexion = "DECONNECTE";
		}
		private function ouverture_flux_mp3():void
		{
			if ( flux_courant.toLowerCase().indexOf(".mp3", 0) == - 1) son_flux = new Sound(new URLRequest(flux_courant + "/;pipi_caca_popo.mp3"));
			else son_flux = new Sound(new URLRequest(flux_courant));
			canal_flux = new SoundChannel();
			effet_flux = new SoundTransform();
			son_flux.addEventListener(IOErrorEvent.IO_ERROR, gestion_erreur_chargement);
			son_flux.addEventListener(ProgressEvent.PROGRESS, gestion_progression_chargement);
			canal_flux = son_flux.play();
			effet_flux.volume = volume_streaming;
			effet_flux.pan = 0;
			canal_flux.soundTransform = effet_flux;
		}
		private function initialisation_connexion(url_net:String):void
		{
			etat_aac = true;
			connexion_reseau = new NetConnection();
			connexion_reseau.addEventListener(NetStatusEvent.NET_STATUS, gestion_status_reseau);
			connexion_reseau.addEventListener(AsyncErrorEvent.ASYNC_ERROR, erreur_asynchrone_reseau);
			connexion_reseau.connect(url_net);
		}
		private function ouverture_flux_aac():void
		{
			effet_flux = new SoundTransform();
			flux_audio = new NetStream(connexion_reseau);
			flux_audio.addEventListener(NetStatusEvent.NET_STATUS, gestion_status_reseau);
			flux_audio.addEventListener(SecurityErrorEvent.SECURITY_ERROR, gestion_erreur_securite);
			flux_audio.addEventListener(AsyncErrorEvent.ASYNC_ERROR, erreur_asynchrone_reseau);
			flux_audio.bufferTime = Number(5);
			flux_audio.play(flux_courant);
			effet_flux.volume = volume_streaming;
			flux_audio.soundTransform = effet_flux;
		}
		private function gestion_volume():void
		{
			volume_streaming = (lecteur.bouton_volume.x - 23) / 82
			effet_flux = new SoundTransform();
			effet_flux.volume = volume_streaming;
			effet_flux.pan = 0;
			if (etat_aac) flux_audio.soundTransform = effet_flux;
			else canal_flux.soundTransform = effet_flux;
		}
		private function gestion_bargraph(numero:int, valeur:int):void
		{
			var objet:Object = new Object();
			switch (numero)
			{
				case 0 : objet = lecteur.bargraph.barre_0; break;
				case 1 : objet = lecteur.bargraph.barre_1; break;
				case 2 : objet = lecteur.bargraph.barre_2; break;
				case 3 : objet = lecteur.bargraph.barre_3; break;
				case 4 : objet = lecteur.bargraph.barre_4; break;
				case 5 : objet = lecteur.bargraph.barre_5; break;
				case 6 : objet = lecteur.bargraph.barre_6; break;
				case 7 : objet = lecteur.bargraph.barre_7; break;
				case 8 : objet = lecteur.bargraph.barre_8; break;
				case 9 : objet = lecteur.bargraph.barre_9;
			}
			if (valeur >= 0) objet.height = valeur;
			else if (etat_aac) objet.height = int(20 * Math.random()) + 10;
			else
			{
				if (numero < 6) objet.height = int(40 * canal_flux.leftPeak); 
				else objet.height = int(40 * canal_flux.rightPeak);
			}
			objet.y = 40 - objet.height;
		}
		private function initialisation_bargraph():void
		{
			for (var i:int = 0; i < 10; i++) gestion_bargraph(i, 1);
		}
		private function gestion_affichage_station():void
		{
			if (liste_station[pointeur_station] != parametre_station) lecteur.bouton_selection_station.visible = true;
			else lecteur.bouton_selection_station.visible = false;
			if  (liste_station[pointeur_station].indexOf("|") != - 1)
			{
				var table:Array = liste_station[pointeur_station].split("|");
				station_texte = controle_texte_affichage(table[1]);
			}
			else station_texte = controle_texte_affichage(liste_station[pointeur_station]);
		}
		private function initialisation_variable():void
		{
			flux_mp3_haut = null;
			flux_mp3_bas = null;
			nom_station = null;
			serveur_rtmp = null;
			repertoire_rtmp = null;
			flux_rtmp_haut = null;
			flux_rtmp_bas = null;
			test_rtmp_haut = null;
			test_rtmp_bas = null;
			domaine_station = null;
			flux_courant = null;
			racine_rtmp = null;
		}
		private function eteindre_voyant_controle():void
		{
			lecteur.voyant_erreur_securite.visible = false;
			lecteur.voyant_erreur_chargement.visible = false;
		}
		private function controle_texte_affichage(texte:String):String
		{
			var reponse:String = new String("");
			texte = texte.replace("à","a").replace("é","e").replace("è","e").replace("ë","e").replace("ê","e").replace("ù","u").replace("ç","c").replace("ô","o");
			for (var i:int = 0; i < texte.length; i++)
			{
				if (texte.charCodeAt(i) >= 0x20 && texte.charCodeAt(i) < 0x7F) reponse += texte.charAt(i);
			}
			return reponse;
		}
		private function recuperation_meta_donnee():void
		{
			switch (mode_streaming)
			{
				case MODE_SHOUTCAST :
					if (etat_proxy) chargement_fichier_meta_proxy(parametre_proxy);
					else chargement_fichier_meta(PHP_SHOUTCAST);
					break;
				case MODE_URL :
					break;
				case MODE_INFOMANIAK :
					chargement_fichier_xls(INFOMANIAK);
			}
		}
		private function defilement_texte(texte:String):String
		{
			if (texte == null) return "";
			if (!etat_marche || lecteur.bouton_selection_station.visible) return texte;
			compteur_defilement++;
			if (compteur_defilement > 20) compteur_defilement = 0;
			if (texte != memoire_texte)
			{
				texte_defilant = texte;
				memoire_texte = texte;
			}
			if (compteur_defilement == 0)
			{
				if (texte_defilant.length > 0) texte_defilant = texte_defilant.substr(1, texte_defilant.length);
				else texte_defilant = ESPACE + texte;
			}
			return texte_defilant;
		}
//		Evènements  -------------------------------------------------------------------------------------------------------------
		private function fin_chargement_liste_xml(e:Event):void
		{
			liste_station = new Array();
			var texte:XML = new XML(e.target.data);
			texte.ignoreWhitespace;
			var lignes:XMLList = texte.elements();
			for each (var ligne:XML in lignes) liste_station.push(ligne.@nom.toString());
			pointeur_station = 0;
			gestion_affichage_station();
		}
		private function fin_chargement_fichier_xml(e:Event):void
		{
			initialisation_variable();
			var texte:XML = new XML(e.target.data);
			texte.ignoreWhitespace;
			var lignes:XMLList = texte.elements();
			for each (var ligne:XML in lignes)
			{
				switch (ligne.@name.toString())
				{
					case "sFeedHigh"       : flux_mp3_haut   = ligne.@value; break;
					case "sFeedLow"        : flux_mp3_bas    = ligne.@value; break;
					case "sNomRadio"       : nom_station     = ligne.@value; break;
					case "sRtmpServer"     : serveur_rtmp    = ligne.@value; break;
					case "sRtmpDir"        : repertoire_rtmp = ligne.@value; break;
					case "sRtmpFeedHigh"   : flux_rtmp_haut  = ligne.@value; break;
					case "sRtmpFeedLow"    : flux_rtmp_bas   = ligne.@value; break;
					case "sDomain"         : domaine_station = ligne.@value; break;
					default : trace("< Paramètre inconnu ou ignoré >");
				}
				trace("- " + ligne.@name + " : " + ligne.@value);
				if (domaine_station == null) domaine_station = flux_mp3_haut.substr(0, flux_mp3_haut.indexOf("-",0));
			}
			preparation_lecteur();
		}
		private function fin_chargement_rtmp(e:Event):void
		{
			var texte:String = new String(e.target.data);
			if (test_acc_haut_bas)
			{
				if (texte == "done2=1")
				{
					trace("- Rtmp High actif");
					test_acc_haut_bas = false;
					if (test_rtmp_bas != null)
					{
						chargement_rtmp_information(test_rtmp_bas);
						return;
					}
				}
				else
				{
					trace("- Rtmp High inactif");
					flux_rtmp_haut = null;
				}
			}
			else
			{
				if (texte == "done2=1") trace("- Rtmp Low actif");
				else
				{
					trace("- Rtmp Low inactif");
					flux_rtmp_bas = null;
				}
			}
			lancer_lecteur(null, null);
		}
		private function fin_chargement_pls(e:Event):void
		{
			var adresse_streaming:String = null;
			var texte_streaming:String = null;
			var ligne_occupee:String = null;
			var ligne_disponible:String = null;
			var ligne:Array = new Array();
			var serveur_invalide:Boolean = false;
			var serveur_sature:Boolean = false;
			flux_courant = null;
			nom_station = null;
			trace("- Fichier pls chargé : \n" + e.currentTarget.data);
			ligne = e.currentTarget.data.split("\n");
			if (ligne[0] == "[playlist]")
			{
				adresse_streaming = ligne[2].toString();
				flux_courant = adresse_streaming.substring((adresse_streaming.indexOf("=") + 1), adresse_streaming.length);
				texte_streaming = ligne[3].toString();
				nom_station = texte_streaming.substring((texte_streaming.indexOf(")") + 1), texte_streaming.length);
				ligne_occupee = texte_streaming.substring((texte_streaming.indexOf("(#") + 6), texte_streaming.indexOf("/"));
				trace("- Lignes occupées : " + ligne_occupee);
				ligne_disponible = texte_streaming.substring((texte_streaming.indexOf("/") + 1), texte_streaming.indexOf(")"));
				trace("- Lignes disponibles : " + ligne_disponible);
				if (ligne_occupee == null && ligne_disponible == null || ligne_occupee == "" && ligne_disponible == "") serveur_invalide = true;
				if (ligne_occupee == ligne_disponible) serveur_sature = true;
				if (serveur_sature) status_connexion = "STATION INDISPONIBLE";
				else if (serveur_invalide) status_connexion = "STATION NON VALIDE";
				else
				{
					station_texte = controle_texte_affichage(nom_station);
					if (!etat_aac) ouverture_flux_mp3();
					else initialisation_connexion(null);
				}
			}
			else status_connexion = "PLS ABSENT";
		}
		private function fin_chargement_fichier_xls(e:Event):void
		{
			trace(e.target.data);
			var texte:String = new String(e.target.data);
			var tableau:Array;
			if (texte.indexOf("<title>", 0) != - 1)
			{
				texte = texte.substr(texte.indexOf("<title>", 0), texte.indexOf("</title>", 0)).replace("<title>", "").replace("</title>", "");
				if (texte.indexOf("Artiste", 0) != - 1 && texte.indexOf("Titre", 0)) tableau = texte.replace("Artiste : ", "").split(" Titre : ")
				else if (texte.indexOf(" - ", 0) != -1) tableau = texte.split(" - ");
				else if (texte.indexOf("   § ", 0) != -1) tableau = texte.split("   § ");
				else tableau[0] = texte;
				if (tableau[0] == null) tableau[0] = "---";
				if (tableau[1] == null) tableau[1] = "---";
				artiste_musique = controle_texte_affichage(tableau[0]);
				titre_musique = controle_texte_affichage(tableau[1]);
				etat_meta = true;
				trace("- Méta Ok");
			}
			else trace("- Méta non present");
		}
		private function fin_chargement_meta(e:Event):void
		{
			var chargeur_local:URLLoader = URLLoader(e.target);
			chargeur_local.addEventListener(IOErrorEvent.IO_ERROR, gestion_erreur_chargement);
			etat_meta = false;
			var texte:String = unescape(chargeur_local.data.toString());
			trace("- Méta données : " + texte);
			var tableau:Array = new Array();
			if (texte.indexOf("StreamTitle") != -1 && texte.indexOf("Information Not Entered by Broadcaster") == -1)
			{
				tableau = texte.split("&StreamUrl");
				texte = tableau[0].substring(tableau[0].indexOf("='") + 2, tableau[0].length - 1);
				tableau = texte.split(" - ")
				if (tableau[0] == null) tableau[0] = "---";
				if (tableau[1] == null) tableau[1] = "---";
				artiste_musique = controle_texte_affichage(tableau[0]);
				titre_musique =  controle_texte_affichage(tableau[1]);
				trace("- Méta Ok");
				etat_meta = true;
				return;
			}
			if (texte.indexOf("404") != -1) trace("- Erreur 404");
			else trace("- Méta non disponible");
		}
		private function action_timer_flux(e:TimerEvent):void
		{
			if (!etat_aac)
			{
				var taille:int = son_flux.bytesLoaded / 1000000;
				if ((taille > 5) && etat_cache)
				{
					arret_lecteur();
					ouverture_flux_mp3();
				}
			}
			gestion_bargraph(compteur_barre, -1);
			compteur_barre++;
			if (compteur_barre >= 10) compteur_barre = 0;
			gestion_volume();
		}
		private function action_timer_affichage(e:TimerEvent):void
		{
			if (etat_meta)
			{
				switch (rotation_affichage)
				{
					case 0 :
						lecteur.texte_connexion.text = status_connexion;
						break;
					case 150 :
						recuperation_meta_donnee();
						break;
					case 300 :
						lecteur.texte_connexion.text = artiste_musique;
						break;
					case 600 :
						lecteur.texte_connexion.text = titre_musique;
						break;
					case 899 :
						rotation_affichage = -1;
				}
				rotation_affichage++;
			}
			else lecteur.texte_connexion.text = status_connexion;
			lecteur.spirale.rotation += 1;
			if (lecteur.spirale.rotation >= 360) lecteur.spirale.rotation = 0;
			if (!etat_proxy) lecteur.voyant_proxy.visible = false;
			else lecteur.voyant_proxy.visible = true;
			if (!etat_aac) lecteur.voyant_aac.visible = false;
			else lecteur.voyant_aac.visible = true;
			lecteur.texte_station.text = defilement_texte(station_texte);
		}
		private function gestion_erreur_chargement(e:IOErrorEvent):void
		{
			trace("- Erreur chargement !");
			status_connexion = "ERREUR CHARGEMENT"
			lecteur.voyant_erreur_chargement.visible = true;
			etat_marche = false;
			timer_flux.stop();
		}
		private function gestion_erreur_securite(e:SecurityErrorEvent):void
		{
			trace("- Erreur sécurité !");
			status_connexion = "ERREUR SECURITE : ";
			lecteur.voyant_erreur_securite.visible = true;
			etat_marche = false;
			timer_flux.stop();
		}
		private function gestion_progression_chargement(e:ProgressEvent):void
		{
			status_connexion = "CONNECTE";
			if (!etat_marche)
			{
				etat_marche = true;
				operation_en_cours = false;
				timer_flux.start();
				recuperation_meta_donnee();
			}
		}
		private function action_bouton_play(e:MouseEvent):void
		{
			if (parametre_station == null)
			{
				//pointeur_station = int(Math.random() * liste_station.length);
				pointeur_station = 0;
				parametre_station = liste_station[pointeur_station];
				lecture_information_station();
			}
			else if (liste_station[pointeur_station] != parametre_station && parametre_station.indexOf("http://", 0) == - 1)
			{
				lecteur.bouton_selection_station.visible = false;
				arret_lecteur();
				parametre_station = liste_station[pointeur_station];
				lecture_information_station();
			}
			else lancer_lecteur("IDEM", null);
			gestion_affichage_station();
		}
		private function action_bouton_stop(e:MouseEvent):void
		{
			arret_lecteur();
		}
		private function gestion_status_reseau(e:NetStatusEvent):void
		{
			switch (e.info.code)
			{
				case "NetConnection.Connect.Success" :
					ouverture_flux_aac();
					break;
				case "NetConnection.Connect.Closed" :
					break;
				case "NetStream.Play.StreamNotFound" :
					arret_lecteur();
					break;
				case "NetStream.Play.PublishNotify" :
					break;
				case "NetStream.Play.UnpublishNotify" :
					arret_lecteur();
					break;
				case "NetStream.Play.Reset" :
					break;
				case "NetStream.Play.Start" :
					break;
				case "NetStream.Buffer.Full" :
					timer_flux.start();
					etat_marche = true;
					status_connexion = "CONNECTE";
					operation_en_cours = false;
					recuperation_meta_donnee();
			}
			trace("- " + e.info.code);
		}
		private function erreur_asynchrone_reseau(e:AsyncErrorEvent):void
		{
			trace("- Erreur synchronisation !");
		}
		private function action_bouton_volume_up(e:MouseEvent):void {modification_volume = false;}
		private function action_bouton_volume_down(e:MouseEvent):void {modification_volume = true;}
		private function action_bouton_volume_move(e:MouseEvent):void 
		{
			if (modification_volume && (e.stageX > 22) && (e.stageX < 106)) lecteur.bouton_volume.x = e.stageX;
		}
		private function action_bouton_station_plus(e:MouseEvent):void
		{
			if (liste_station.length == 0) return;
			pointeur_station++;
			if (pointeur_station >= liste_station.length) pointeur_station = 0;
			gestion_affichage_station();
		}
		private function action_bouton_station_moins(e:MouseEvent):void
		{
			if (liste_station.length == 0) return;
			pointeur_station--;
			if (pointeur_station < 0) pointeur_station = liste_station.length - 1;
			gestion_affichage_station();
		}
		private function action_bouton_flux(e:MouseEvent):void
		{
			if (operation_en_cours) return;
			var test_flux:String = null;
			var parametre_1:String;
			var parametre_2:String;
			var issue_de_secours:int = 0;
			while (test_flux == null)
			{
				pointeur_flux++;
				if (pointeur_flux > 3) pointeur_flux = 0;
				switch (pointeur_flux)
				{
					case 0 :
						test_flux = flux_mp3_haut;
						parametre_1 = "H";
						parametre_2 = "MP3";
						break;
					case 1 :
						test_flux = flux_mp3_bas;
						parametre_1 = "L";
						parametre_2 = "MP3";
						break;
					case 2 :
						test_flux = flux_rtmp_haut;
						parametre_1 = "H";
						parametre_2 = "AAC";
						break;
					case 3 :
						test_flux = flux_rtmp_bas;
						parametre_1 = "L";
						parametre_2 = "AAC";
				}
				issue_de_secours++;
				if (issue_de_secours > 5) return;
			}
			arret_lecteur();
			lancer_lecteur(parametre_2, parametre_1);
		}
		private function action_bouton_selection_station(e:MouseEvent):void
		{
			lecteur.bouton_selection_station.visible = false;
			arret_lecteur();
			parametre_station = liste_station[pointeur_station];
			lecture_information_station();
		}
//		Fenêtre de paramètrages		
		private function action_touche_enfoncee(e:KeyboardEvent):void
		{
			if (e.keyCode == Keyboard.ENTER)
			{
				trace(FENETRE_SAISIE.texte_saisie.text);
				action_bouton_quitter_saisie(null);
				arret_lecteur();
				parametre_station = FENETRE_SAISIE.texte_saisie.text;
				lecture_information_station();
			}
		}
		private function action_bouton_saisie_flux(e:MouseEvent):void
		{
			addChild(FENETRE_SAISIE);
			FENETRE_SAISIE.x = 25;
			FENETRE_SAISIE.y = 7.5;
			FENETRE_SAISIE.alpha = .85
			FENETRE_SAISIE.bouton_quitter_saisie.addEventListener(MouseEvent.CLICK, action_bouton_quitter_saisie);
			FENETRE_SAISIE.texte_saisie.addEventListener(MouseEvent.CLICK, action_commencer_saisie);
			FENETRE_SAISIE.bouton_cache.addEventListener(MouseEvent.CLICK, action_bouton_cache);
			FENETRE_SAISIE.bouton_proxy.addEventListener(MouseEvent.CLICK, action_bouton_proxy);
			FENETRE_SAISIE.bouton_liste_1.addEventListener(MouseEvent.CLICK, action_bouton_liste_1);
			FENETRE_SAISIE.bouton_liste_2.addEventListener(MouseEvent.CLICK, action_bouton_liste_2);
			FENETRE_SAISIE.bouton_cache.buttonMode = true;
			FENETRE_SAISIE.bouton_proxy.buttonMode = true;
			FENETRE_SAISIE.bouton_liste_1.buttonMode = true;
			FENETRE_SAISIE.bouton_liste_2.buttonMode = true;
			action_bouton_cache(null);
			action_bouton_proxy(null);
			if (numero_liste == 1) action_bouton_liste_1(null);
			else action_bouton_liste_2(null);
			stage.addEventListener(KeyboardEvent.KEY_DOWN, action_touche_enfoncee);
		}
		private function action_bouton_quitter_saisie(e:MouseEvent):void
		{
			FENETRE_SAISIE.bouton_quitter_saisie.removeEventListener(MouseEvent.CLICK, action_bouton_quitter_saisie);
			FENETRE_SAISIE.texte_saisie.removeEventListener(MouseEvent.CLICK, action_commencer_saisie);
			FENETRE_SAISIE.bouton_cache.removeEventListener(MouseEvent.CLICK, action_bouton_cache);
			FENETRE_SAISIE.bouton_proxy.removeEventListener(MouseEvent.CLICK, action_bouton_proxy);
			FENETRE_SAISIE.bouton_liste_1.removeEventListener(MouseEvent.CLICK, action_bouton_liste_1);
			FENETRE_SAISIE.bouton_liste_2.removeEventListener(MouseEvent.CLICK, action_bouton_liste_2);
			stage.removeEventListener(KeyboardEvent.KEY_DOWN, action_touche_enfoncee);
			removeChild(this.FENETRE_SAISIE);
		}
		private function action_commencer_saisie(e:MouseEvent):void
		{
			if (!une_fois)
			{
				une_fois = true;
				FENETRE_SAISIE.texte_saisie.text = "";
			}
		}
		private function action_bouton_cache(e:MouseEvent):void
		{
			if (e != null) etat_cache = !etat_cache;
			if (etat_cache) FENETRE_SAISIE.bouton_cache.alpha = 1;
			else FENETRE_SAISIE.bouton_cache.alpha = .4;
		}
		private function action_bouton_proxy(e:MouseEvent):void
		{
			if (e != null) etat_proxy = !etat_proxy;
			if (etat_proxy) FENETRE_SAISIE.bouton_proxy.alpha = 1;
			else FENETRE_SAISIE.bouton_proxy.alpha = .4;
		}
		private function action_bouton_liste_1(e:MouseEvent):void
		{
			FENETRE_SAISIE.bouton_liste_1.alpha = 1;
			FENETRE_SAISIE.bouton_liste_2.alpha = .4;
			numero_liste = 1;
			if (e != null) chargement_liste_xml(parametre_liste_1);
		}
		private function action_bouton_liste_2(e:MouseEvent):void
		{
			FENETRE_SAISIE.bouton_liste_1.alpha = .4;
			FENETRE_SAISIE.bouton_liste_2.alpha = 1;
			numero_liste = 2;
			if (e != null) chargement_liste_xml(parametre_liste_2);
		}
	}
}