begin process at 2012 05 26 05:48:30
  Trouver un code source :
 
dans
 
Accueil > 

Code

 > 

Audio

 > ERYPIANO V2.03 CS4 AS3

ERYPIANO V2.03 CS4 AS3


 Information sur la source

Note :
2 / 10 - par 1 personne
2,00 / 10

  • 1

  • 2

  • 3

  • 4

  • 5

  • 6

  • 7

  • 8

  • 9

  • 10
Catégorie :Audio Classé sous :piano, virtuel, CS4, AS3, flash Niveau :Initié Date de création :07/12/2010 Date de mise à jour :28/12/2010 12:14:41 Vu / téléchargé :4 044 / 213

Auteur : VBtoTRASH

Ecrire un message privé
Site perso
Commentaire sur cette source (51)
Ajouter un commentaire et/ou une note

 Description

Cliquez pour voir la capture en taille normale
Le site ErySoft a été sujet à une attaque virale. J'ai rétabli ce dernier, mais Google mentionne et bloque toujours son accès, le temps de réexaminer l'intégrité de ce dernier.

Le 28/12/2011

Chose promise, chose due !

Une première remarque incisive : Flash c'est "POOrrave", et pas un peu. C'est juste bon à faire de la publicité, et des jeux.
Quant à savoir si cette nouvelle source est de la POO, ou pas de la POO, et bien je ne sais "pôô", et c'est tant mieux.
J'ai amélioré le code, en utilisant pas mal de possibilités DE BASES pour faire discuter les .as, mais il faut mieux utiliser les vieilles méthodes qui ont faites leurs preuves. Car si vous désirez obtenir une programme qui ne bouffe pas toutes les ressources µP, il faut éviter de manipuler les tas d'objets prédéfinis juste bons pour faire de la Pub ... du clinquant, du "tape-à-l'½il", du "m'as-tu vu", et j'en passe et des meilleurs.

Les sons ne sont pas présents sur ce site, donc il faut vous rendre à l'adresse suivante, et télécharger le .zip de la version 2 :

http://www.erysoft.fr/erypiano/index.html

Pour ceux qui aiment la bidouille balèze, je vous conseille Pascal DOS 7, si vos machines acceptent encore d'être triturées.

VERSION 1
========

NOTE : Je ne cherche pas à réduire la taille du fichier obtenu. La présence des 88 sons est voulue.

C'est un piano virtuel de 88 touches, avec les sons mp3 CBR128 pré-enregistrés. La taille du fichier fla fait plus de 25 Mo, alors il ne m'est pas possible de le placer sur ce site. De même, le fichier swf compilé fait plus de 15 Mo. Mais vous pouvez trouver les sources complètes et le fichier swf à l'adresse suivante :

http://www.erysoft.fr/erypiano/index.html

On m'a dit qu'il fallait utiliser la POO ! Ben vous avez du pot, c'est pratiquement de la pure POO. Mais je pense franchement que les classes compliquent la compréhension ... enfin, c'est mon avis.

Ce piano virtuel peut jouer des séquences enregistrées au format xml. Pour faire ces fichiers, je vous fournirai l'exécutable VB6 quand il sera vraiment au point. Vous avez un exemple (Etude N°1 Opus 25 de Chopin) inclus, que vous pourrez analyser si cela vous intéresse.

Vous pouvez jouer à l'aide de la souris, ou alors faire des accords en vous positionnant sur la position ACCORD/ARPEGE. Une fenêtre d'aide vous donnera l'utilité de chaque bouton.

Il est préférable d'exécuter cette application avec un lecteur flash. Avec un navigateur, çà rame à mort !

Source

  • package piano
  • {
  • import flash.display.MovieClip;
  • //import flash.ui.Keyboard;
  • import flash.media.Sound;
  • import flash.media.SoundChannel;
  • import flash.media.SoundTransform
  • import flash.utils.Timer;
  • import flash.display.Sprite;
  • import flash.events.TimerEvent;
  • import flash.events.Event;
  • public class erypiano extends MovieClip
  • {
  • public const ERYPIANO : String = new String("ERYPIANO V2.03");
  • public const NOTE_SOURIS : int = 31;
  • public const MODE_SEQUENCEUR : int = 0;
  • public const MODE_ACCORD : int = 1;
  • private var parametre : Object = loaderInfo.parameters;
  • private var xml_chargeur : chargeur_xml;
  • private var chargeur_note : chargeur_son;
  • private var bouton_jouer : bouton;
  • private var bouton_stopper : bouton;
  • public var bouton_reculer : bouton;
  • public var bouton_avancer : bouton;
  • private var bouton_menu_haut : bouton;
  • private var bouton_menu_bas : bouton;
  • private var bouton_menu_valider : bouton;
  • private var potentiometre_tempo : potentiometre;
  • private var potentiometre_volume : potentiometre;
  • public var lcd : affichage_lcd;
  • public var aide : affichage_aide;
  • public var accord : generateur_accord;
  • public var clavier : clavier_piano;
  • public var marquage : affichage_point;
  • public var sequenceur : sequenceur_note;
  • public var polyphonie : affichage_led;
  • private var cache : cache_clavier = new cache_clavier();
  • private var fenetre : fenetre_aide = new fenetre_aide();
  • private var midi : String = parametre.midi;
  • private var midi_xml : String = parametre.xidi;
  • private var sequence : String = parametre.melo;
  • private var configuration : String = parametre.conf;
  • public var mode_piano : int;
  • public var volume_piano : int = 80;
  • public var valeur_tempo : int = 50;
  • private var initialisation : Boolean = false;
  • // Initialisation des objets primaires
  • public function erypiano():void
  • {
  • lcd = new affichage_lcd(this, lcd_texte, "F00", "F01", "F02");
  • lcd.addEventListener("F00", charger_note_instrument);
  • lcd.addEventListener("F01", charger_sequence_xidi);
  • lcd.addEventListener("F02", controle_bouton_stop);
  • polyphonie = new affichage_led(this, true, 720, 18);
  • marquage = new affichage_point(this, true, 20, 49, cache);
  • accord = new generateur_accord(this);
  • sequenceur = new sequenceur_note(this);
  • chargeur_note = new chargeur_son("F10", "F11");
  • chargeur_note.addEventListener("F10", reception_gamme);
  • chargeur_note.addEventListener("F11", echo_chargement_son);
  • xml_chargeur = new chargeur_xml("F20", "F21", "F22", "F23");
  • xml_chargeur.addEventListener("F20", reception_midi_xml);
  • xml_chargeur.addEventListener("F21", reception_configuration);
  • xml_chargeur.addEventListener("F22", reception_sequence);
  • xml_chargeur.addEventListener("F23", echo_chargement_xml);
  • if (configuration == null) configuration = "./configuration.xml";
  • xml_chargeur.chargement_midi_xml(configuration, "configuration");
  • }
  • // Initialisation des objets secondaires
  • private function initialisation_objet():void
  • {
  • if (initialisation) return;
  • clavier = new clavier_piano(cache, "F30", "F31");
  • clavier.addEventListener("F30", touche_enfoncee);
  • clavier.addEventListener("F31", touche_relachee);
  • aide = new affichage_aide(this, fenetre, 377.5, 100);
  • aide.etat_actif = true;
  • initialisation_potentiometre();
  • initialisation_bouton();
  • if (sequence == null) sequence = "./sequence.xml";
  • xml_chargeur.chargement_midi_xml(sequence, "sequence");
  • initialisation = true;
  • }
  • // Initialisation des boutons (Retours par objets "Function")
  • private function initialisation_bouton():void
  • {
  • bouton_jouer = new bouton(lutin_bouton_jouer, true, 0, action_bouton_jouer, action_bouton_dedans, action_bouton_dehors);
  • bouton_stopper = new bouton(lutin_bouton_stopper, true, 1, action_bouton_stopper, action_bouton_dedans, action_bouton_dehors);
  • bouton_stopper.visibilite(false);
  • bouton_reculer = new bouton(lutin_bouton_reculer, true, 2, action_bouton_reculer, action_bouton_dedans, action_bouton_dehors);
  • bouton_reculer.visibilite(false);
  • bouton_avancer = new bouton(lutin_bouton_avancer, true, 3, action_bouton_avancer, action_bouton_dedans, action_bouton_dehors);
  • bouton_avancer.visibilite(false);
  • bouton_menu_haut = new bouton(lutin_bouton_menu_haut, true, 4, action_bouton_menu_haut, action_bouton_dedans, action_bouton_dehors);
  • bouton_menu_valider = new bouton(lutin_bouton_menu_valider, true, 5, action_bouton_menu_valider, action_bouton_dedans, action_bouton_dehors);
  • bouton_menu_bas = new bouton(lutin_bouton_menu_bas, true, 6, action_bouton_menu_bas, action_bouton_dedans, action_bouton_dehors);
  • }
  • // Initialisation des potentiomètres
  • private function initialisation_potentiometre():void
  • {
  • potentiometre_volume = new potentiometre(0, 580, 680, lutin_bouton_volume, reglage_volume);
  • potentiometre_tempo = new potentiometre(1, 430, 530, lutin_bouton_tempo, reglage_tempo);
  • }
  • // Fonction d'incidence du potentiomètre volume
  • private function reglage_volume(valeur:int):void
  • {
  • volume_piano = valeur;
  • lcd.message_lcd("VOLUME : " + volume_piano.toString(), 20)
  • }
  • // Fonction d'incidence du potentiomètre tempo
  • private function reglage_tempo(valeur:int):void
  • {
  • valeur_tempo = valeur;
  • lcd.message_lcd("TEMPO : " + sequenceur.calcul_tempo().toString() + "%", 20)
  • }
  • // Fonction d'incidence commune aux boutons (Souris dedans)
  • private function action_bouton_dedans(index:int):void
  • {
  • if (!aide.etat_actif) return;
  • var texte:String = new String("");
  • switch(index)
  • {
  • case 0 : texte = "Jouer sélection"; break;
  • case 1 : texte = "Stopper sélection"; break;
  • case 2 : texte = "Supprimer dernière note"; break;
  • case 3 : texte = "Effacer toutes les notes"; break;
  • case 4 : texte = "Option suivante"; break;
  • case 5 : texte = "Valider ou changer valeur"; break;
  • case 6 : texte = "Option précédente"; break;
  • }
  • aide.apparition_aide(texte, 708, 49);
  • }
  • // Fonction d'incidence commune aux boutons (Souris dehors)
  • private function action_bouton_dehors():void
  • {
  • if (aide.etat_actif) aide.disparition_aide();
  • }
  • // Fonction d'incidence du bouton jouer
  • private function action_bouton_jouer():void
  • {
  • if (mode_piano == MODE_SEQUENCEUR && sequenceur.donnee != null) sequenceur.demarrage_sequenceur();
  • else if (mode_piano == MODE_ACCORD) accord.jouer_accord();
  • }
  • // Fonction d'incidence du bouton stopper
  • private function action_bouton_stopper():void
  • {
  • sequenceur.etat_actif = false;
  • }
  • // Fonction d'incidence du bouton reculer
  • private function action_bouton_reculer():void
  • {
  • var index:int = accord.supprimer_note();
  • if (index >= 0) marquage.gestion_point_note(false, index);
  • }
  • // Fonction d'incidence du bouton avancer
  • private function action_bouton_avancer():void
  • {
  • marquage.initialisation_point();
  • accord.initialisation_accord();
  • }
  • // Fonction d'incidence du bouton menu vers le haut
  • private function action_bouton_menu_haut():void
  • {
  • lcd.option_plus();
  • }
  • // Fonction d'incidence du bouton menu vers le bas
  • private function action_bouton_menu_bas():void
  • {
  • lcd.option_moins();
  • }
  • // Fonction d'incidence du bouton menu valiser
  • private function action_bouton_menu_valider():void
  • {
  • lcd.option_valider();
  • }
  • // Evènement ----------------------------------------------------------------------------------------------------------------
  • // Evènement relatif à la fin du chargement d'un fichier midi xml
  • private function reception_midi_xml(e:Event):void
  • {
  • sequenceur.donnee = xml_chargeur.midi_xml;
  • echo_chargement_xml(null);
  • lcd.message_lcd("SEQUENCE OK", 20)
  • }
  • // Evènement relatif à la fin du chargement du fichier de configuration
  • private function reception_configuration(e:Event):void
  • {
  • lcd.instrument = xml_chargeur.configuration;
  • echo_chargement_xml(null);
  • lcd.charger_instrument();
  • }
  • // Evènement relatif à la fin du chargement du catalogue des fichiers midi xml disponibles
  • private function reception_sequence(e:Event):void
  • {
  • lcd.sequence = xml_chargeur.sequence;
  • echo_chargement_xml(null);
  • lcd.charger_xidi();
  • }
  • // Evènement relatif à la fin d'un chargement xml avec échec
  • private function echo_chargement_xml(e:Event):void
  • {
  • lcd.message_lcd(xml_chargeur.echo, 20);
  • }
  • // Evènement relatif à la fin du chargement des fichiers sons
  • private function reception_gamme(e:Event):void
  • {
  • sequenceur.gamme = chargeur_note.gamme;
  • echo_chargement_son(null);
  • initialisation_objet();
  • }
  • // Evènement relatif à la fin d'un chargement son avec échec
  • private function echo_chargement_son(e:Event):void
  • {
  • lcd.message_lcd(chargeur_note.echo, 20);
  • }
  • // Evènement relatif au clic de la souris sur le clavier
  • private function touche_enfoncee(e:Event):void
  • {
  • if (clavier.note_piano == -1) return;
  • sequenceur.jouer_note_index(clavier.note_piano, 127, 0, 0, NOTE_SOURIS, 0);
  • if (mode_piano == MODE_ACCORD)
  • {
  • accord.ajouter_note(clavier.note_piano);
  • marquage.gestion_point_note(true, clavier.note_piano);
  • }
  • }
  • // Evènement relatif au clic relaché de la souris sur le clavier
  • private function touche_relachee(e:Event):void
  • {
  • sequenceur.stopper_note(NOTE_SOURIS);
  • if (mode_piano == MODE_SEQUENCEUR) marquage.gestion_point_note(false, sequenceur.note[NOTE_SOURIS].point);
  • }
  • // Evénement relatif aux chargements d'instruments
  • private function charger_note_instrument(e:Event):void
  • {
  • try {chargeur_note.chargement_serie_son(lcd.chemin);}
  • catch (e:Error)
  • {
  • lcd.message_lcd("INSTRUMENT NON TROUVE", 40);
  • }
  • }
  • // Evénement relatif aux chargements dde séquences xidi
  • public function charger_sequence_xidi(e:Event):void
  • {
  • xml_chargeur.chargement_midi_xml(lcd.chemin, "xidi");
  • }
  • // Evénement relatif au controle du bouton stop
  • public function controle_bouton_stop(e:Event):void
  • {
  • try {bouton_stopper.visibilite(sequenceur.etat_actif);}
  • catch (e:Error) {}
  • }
  • }
  • }
package piano
{
	import flash.display.MovieClip;
	//import flash.ui.Keyboard;
	import flash.media.Sound;
	import flash.media.SoundChannel;
	import flash.media.SoundTransform
	import flash.utils.Timer;
	import flash.display.Sprite;
	import flash.events.TimerEvent;
	import flash.events.Event;
		
	public class erypiano extends MovieClip
	{
		public  const ERYPIANO				: String = new String("ERYPIANO V2.03");
		
		public  const NOTE_SOURIS			: int = 31;
		public  const MODE_SEQUENCEUR		        : int = 0;
		public  const MODE_ACCORD			: int = 1;

		private var parametre				: Object = loaderInfo.parameters;
		
		private var xml_chargeur			: chargeur_xml;
		private var chargeur_note			: chargeur_son;
		private var bouton_jouer			: bouton;
		private var bouton_stopper			: bouton;
		public  var bouton_reculer			: bouton;
		public  var bouton_avancer			: bouton;
		private var bouton_menu_haut		        : bouton;
		private var bouton_menu_bas			: bouton;
		private var bouton_menu_valider		        : bouton;
		private var potentiometre_tempo		        : potentiometre;
		private var potentiometre_volume	        : potentiometre;
		public  var lcd					: affichage_lcd;
		public  var aide				: affichage_aide;
		public  var accord				: generateur_accord;
		public  var clavier				: clavier_piano;
		public  var marquage				: affichage_point;
		public  var sequenceur				: sequenceur_note;
		public  var polyphonie				: affichage_led;
		
		private var cache				: cache_clavier = new cache_clavier();
		private var fenetre				: fenetre_aide = new fenetre_aide();
		
		private var midi				: String = parametre.midi;
		private var midi_xml				: String = parametre.xidi;
		private var sequence				: String = parametre.melo;
		private var configuration			: String = parametre.conf;
		
		public  var mode_piano				: int;
		public  var volume_piano			: int = 80;
		public  var valeur_tempo			: int = 50;
		
		private var initialisation			: Boolean = false;
		
		// Initialisation des objets primaires
		public function erypiano():void
		{
			lcd = new affichage_lcd(this, lcd_texte, "F00", "F01", "F02");
			lcd.addEventListener("F00", charger_note_instrument);
			lcd.addEventListener("F01", charger_sequence_xidi);
			lcd.addEventListener("F02", controle_bouton_stop);
			polyphonie = new affichage_led(this, true, 720, 18);
			marquage = new affichage_point(this, true, 20, 49, cache);
			accord = new generateur_accord(this);
			sequenceur = new sequenceur_note(this);
			chargeur_note = new chargeur_son("F10", "F11");
			chargeur_note.addEventListener("F10", reception_gamme);
			chargeur_note.addEventListener("F11", echo_chargement_son);
			xml_chargeur = new chargeur_xml("F20", "F21", "F22", "F23");
			xml_chargeur.addEventListener("F20", reception_midi_xml);
			xml_chargeur.addEventListener("F21", reception_configuration);
			xml_chargeur.addEventListener("F22", reception_sequence);
			xml_chargeur.addEventListener("F23", echo_chargement_xml);
			if (configuration == null) configuration = "./configuration.xml";
			xml_chargeur.chargement_midi_xml(configuration, "configuration");
		}
		// Initialisation des objets secondaires
		private function initialisation_objet():void
		{
			if (initialisation) return;
			clavier = new clavier_piano(cache, "F30", "F31");
			clavier.addEventListener("F30", touche_enfoncee);
			clavier.addEventListener("F31", touche_relachee);
			aide = new affichage_aide(this, fenetre, 377.5, 100);
			aide.etat_actif = true;
			initialisation_potentiometre();
			initialisation_bouton();
			if (sequence == null) sequence = "./sequence.xml";
			xml_chargeur.chargement_midi_xml(sequence, "sequence");
			initialisation = true;
		}
		// Initialisation des boutons (Retours par objets "Function")
		private function initialisation_bouton():void
		{
			bouton_jouer = new bouton(lutin_bouton_jouer, true, 0, action_bouton_jouer, action_bouton_dedans, action_bouton_dehors);
			bouton_stopper = new bouton(lutin_bouton_stopper, true, 1, action_bouton_stopper, action_bouton_dedans, action_bouton_dehors);
			bouton_stopper.visibilite(false);
			bouton_reculer = new bouton(lutin_bouton_reculer, true, 2, action_bouton_reculer, action_bouton_dedans, action_bouton_dehors);
			bouton_reculer.visibilite(false);
			bouton_avancer = new bouton(lutin_bouton_avancer, true, 3, action_bouton_avancer, action_bouton_dedans, action_bouton_dehors);
			bouton_avancer.visibilite(false);
			bouton_menu_haut = new bouton(lutin_bouton_menu_haut, true, 4, action_bouton_menu_haut, action_bouton_dedans, action_bouton_dehors);
			bouton_menu_valider = new bouton(lutin_bouton_menu_valider, true, 5, action_bouton_menu_valider, action_bouton_dedans, action_bouton_dehors);
			bouton_menu_bas = new bouton(lutin_bouton_menu_bas, true, 6, action_bouton_menu_bas, action_bouton_dedans, action_bouton_dehors);
		}
		// Initialisation des potentiomètres
		private function initialisation_potentiometre():void
		{
			potentiometre_volume = new potentiometre(0, 580, 680, lutin_bouton_volume, reglage_volume);
			potentiometre_tempo = new potentiometre(1, 430, 530, lutin_bouton_tempo, reglage_tempo);
		}
		// Fonction d'incidence du potentiomètre volume
		private function reglage_volume(valeur:int):void
		{
			volume_piano = valeur;
			lcd.message_lcd("VOLUME : " + volume_piano.toString(), 20)
		}
		// Fonction d'incidence du potentiomètre tempo
		private function reglage_tempo(valeur:int):void
		{
			valeur_tempo = valeur;
			lcd.message_lcd("TEMPO : " + sequenceur.calcul_tempo().toString() + "%", 20)
		}
		// Fonction d'incidence commune aux boutons (Souris dedans)
		private function action_bouton_dedans(index:int):void
		{
			if (!aide.etat_actif) return;
			var texte:String = new String("");
			switch(index)
			{
				case 0 : texte = "Jouer sélection"; break;
				case 1 : texte = "Stopper sélection"; break;
				case 2 : texte = "Supprimer dernière note"; break;
				case 3 : texte = "Effacer toutes les notes"; break;
				case 4 : texte = "Option suivante"; break;
				case 5 : texte = "Valider ou changer valeur"; break;
				case 6 : texte = "Option précédente"; break;
			}
			aide.apparition_aide(texte, 708, 49);
		}
		// Fonction d'incidence commune aux boutons (Souris dehors)
		private function action_bouton_dehors():void
		{
			if (aide.etat_actif) aide.disparition_aide();
		}
		// Fonction d'incidence du bouton jouer
		private function action_bouton_jouer():void 
		{
			if (mode_piano == MODE_SEQUENCEUR && sequenceur.donnee != null) sequenceur.demarrage_sequenceur();
			else if (mode_piano == MODE_ACCORD) accord.jouer_accord();
		}
		// Fonction d'incidence du bouton stopper
		private function action_bouton_stopper():void 
		{
			sequenceur.etat_actif = false;
		}
		// Fonction d'incidence du bouton reculer
		private function action_bouton_reculer():void 
		{
			var index:int = accord.supprimer_note();
			if (index >= 0)	marquage.gestion_point_note(false, index);
		}
		// Fonction d'incidence du bouton avancer
		private function action_bouton_avancer():void 
		{
			marquage.initialisation_point();
			accord.initialisation_accord();
		}
		// Fonction d'incidence du bouton menu vers le haut
		private function action_bouton_menu_haut():void 
		{
			lcd.option_plus();
		}
		// Fonction d'incidence du bouton menu vers le bas
		private function action_bouton_menu_bas():void 
		{
			lcd.option_moins();
		}
		// Fonction d'incidence du bouton menu valiser
		private function action_bouton_menu_valider():void 
		{
			lcd.option_valider();
		}
//		Evènement ----------------------------------------------------------------------------------------------------------------
		// Evènement relatif à la fin du chargement d'un fichier midi xml
		private function reception_midi_xml(e:Event):void
		{
			sequenceur.donnee = xml_chargeur.midi_xml;
			echo_chargement_xml(null);
			lcd.message_lcd("SEQUENCE OK", 20)
		}
		// Evènement relatif à la fin du chargement du fichier de configuration
		private function reception_configuration(e:Event):void
		{
			lcd.instrument = xml_chargeur.configuration;
			echo_chargement_xml(null);
			lcd.charger_instrument();
		}
		// Evènement relatif à la fin du chargement du catalogue des fichiers midi xml disponibles
		private function reception_sequence(e:Event):void
		{
			lcd.sequence = xml_chargeur.sequence;
			echo_chargement_xml(null);
			lcd.charger_xidi();
		}
		// Evènement relatif à la fin d'un chargement xml avec échec
		private function echo_chargement_xml(e:Event):void
		{
			lcd.message_lcd(xml_chargeur.echo, 20);
		}
		// Evènement relatif à la fin du chargement des fichiers sons
		private function reception_gamme(e:Event):void
		{
			sequenceur.gamme = chargeur_note.gamme;
			echo_chargement_son(null);
			initialisation_objet();
		}
		// Evènement relatif à la fin d'un chargement son avec échec
		private function echo_chargement_son(e:Event):void
		{
			lcd.message_lcd(chargeur_note.echo, 20);
		}
		// Evènement relatif au clic de la souris sur le clavier
		private function touche_enfoncee(e:Event):void
		{
			if (clavier.note_piano == -1) return;
			sequenceur.jouer_note_index(clavier.note_piano, 127, 0, 0, NOTE_SOURIS, 0);
			if (mode_piano == MODE_ACCORD)
			{
				accord.ajouter_note(clavier.note_piano);
				marquage.gestion_point_note(true, clavier.note_piano);
			}
		}
		// Evènement relatif au clic relaché de la souris sur le clavier
		private function touche_relachee(e:Event):void
		{
			sequenceur.stopper_note(NOTE_SOURIS);
			if (mode_piano == MODE_SEQUENCEUR) marquage.gestion_point_note(false, sequenceur.note[NOTE_SOURIS].point);
		}
		// Evénement relatif aux chargements d'instruments
		private function charger_note_instrument(e:Event):void
		{
			try {chargeur_note.chargement_serie_son(lcd.chemin);}
			catch (e:Error)
			{
				lcd.message_lcd("INSTRUMENT NON TROUVE", 40);
			}
		}
		// Evénement relatif aux chargements dde séquences xidi
		public function charger_sequence_xidi(e:Event):void
		{
			xml_chargeur.chargement_midi_xml(lcd.chemin, "xidi");
		}
		// Evénement relatif au controle du bouton stop
		public function controle_bouton_stop(e:Event):void
		{
			try {bouton_stopper.visibilite(sequenceur.etat_actif);}
			catch (e:Error) {}
		}
	}
}

 Conclusion

Il y aura ENCORE une suite

 Fichier Zip

Les Membres Club peuvent télécharger directement un fichier contenu dans le zip sans télécharger le zip en entier !

Télécharger le zip


 Historique

08 décembre 2010 07:56:40 :
Suppression code
08 décembre 2010 16:44:14 :
Note supplémentaire
13 décembre 2010 18:38:04 :
Mise à jour pour la prochaine version
17 décembre 2010 19:13:47 :
Mise à jour version 2
18 décembre 2010 15:52:31 :
Modification titre
28 décembre 2010 12:14:42 :
Accès site ErySoft

 Sources du même auteur

Source avec Zip Source avec une capture ERYSTREAMING V2.05 CS4 AS3
Source avec Zip Source avec une capture ERYSOKOBAN V1.02 CS4 AS3
Source avec Zip Source avec une capture ERYSKYPLAYER_MINI
Source avec Zip Source avec une capture ERYSKYVIDÉO V1.05 & V2.00
Source avec Zip Source avec une capture ERYOUTUBE : TÉLÉCHARGEMENT VIDÉO YOUTUBE FLASH CS4 AS3 V2.20

 Sources de la même categorie

Source avec Zip Source avec une capture ERYSTREAMING V2.05 CS4 AS3 par VBtoTRASH
Source avec Zip Source avec une capture ERYSKYPLAYER_MINI par VBtoTRASH
Source avec Zip Source avec une capture LECTEUR AUDIO MULTI-PISTES par uaemon
Source avec Zip CHARGER SON EXTERNE FLASH AS par tranber78
Source avec une capture CLASS SOUNDSPECTRUM par top30

 Sources en rapport avec celle ci

Source avec Zip Source avec une capture ERYSTREAMING V2.05 CS4 AS3 par VBtoTRASH
Source avec Zip Source avec une capture ERYSOKOBAN V1.02 CS4 AS3 par VBtoTRASH
Source avec Zip Source avec une capture ERYSKYPLAYER_MINI par VBtoTRASH
Source avec Zip Source avec une capture ERYSKYVIDÉO V1.05 & V2.00 par VBtoTRASH
Source avec Zip Source avec une capture ERYOUTUBE : TÉLÉCHARGEMENT VIDÉO YOUTUBE FLASH CS4 AS3 V2.20 par VBtoTRASH

Commentaires et avis

Commentaire de pegase31 le 07/12/2010 18:54:56 administrateur CS

POO ? oui, ça commence à y ressembler... Mais ça reste trop procédural dans ta gestion des données pour vraiment être de la POO.

Plusieurs choses :
- Pourquoi cette lourdeur dans le code et toutes ces centaines de variables bizarres alors que la génération par boucle seraient tout à fait fonctionnelles ?
- Pourquoi un afficheur LED avec 32 "case" alors qu'un simple ciblage dans un tableau contenant tes objets serait si pratique et gérable sur une seule ligne ?
- Pourquoi transformes-tu ton XML chargé en tableau au lieu de piocher directement dedans ? ça double les données sans raisons ...
- Pourquoi places-tu le "parent" de l'objet dans le constructeur de classes, ainsi que toutes les méthodes, alors que de simples écouteur permettrais de gérer les évènements facilement ? (ça c'est de la POO)
- "else/if", "switch/case" à foison, partout, trop bien trop... pareil pour les variables et constants .. de simples fonctions de gestion du bouton sont simples et efficace comparé à cet urinage de code en règles ...
- Des movieclip partout, alors que des sprites seraient plus légers à la gestions (détail)
- Pourquoi étendre des movieclips dans tes AS, puisqu'ils n'affichent rien ? Autant faire des classes statiques ...
- et j'ai arrêté là l'analyse du code .. trop fouillis ..

En quoi n'est-ce pas de la POO :
- Uutiliser des objets pour ce qu'ils sont : ce qu'ils étendent (ou alors ce sont des classes statiques)
- Les objets ne doivent avoir aucun lien avec leurs parent et ne doivent discuter entre eux que par des évènements (qui sont prévus pour ça)

Ton code est trop lourd, il pourrait sans soucis être diminué à son tiers avec quelques fonctions bien senties et quelques formules mathématiques.

Les objets déja présents sur la scène sont simples à placer, mais en contre-partie, tu dois les appeler 1 par 1 par leurs nom d'occurrence. Une génération de clips piochés par liaison dans la bibliothèque aurait pour effet de ne pas avoir à jongler avec tout ça.

Bref, encore beaucoup de boulot, mais on sent que tu ne maîtrises pas flash et que tu codes comme dans un autre langage (je sais, je fais pareil en php). Trop linéaire, trop statique et même si tu as créés des .as, ils n'ont effectivement aucun intérêt au final. D'où le fait de t'embrouiller plutôt que de t'aider ..

Courage, tu commence juste à mettre la tête dedans, mais il y a beaucoup de boulot.

Peg'

ps: ok, "ça marche et peu importe comment on le code", mais à ce moment-là ne nous montre pas la source, c'est mieux ;)

Commentaire de Chaotikmind le 07/12/2010 19:05:51

omg, ca se passe de commentaires,
plutôt que de diverger sur le code, je vais juste te donner un indice
la différence de fréquence entre 2 demi ton est racine douzième de 2

Corrige tout ca s'il te plait, ca fait mal aux yeux...

Commentaire de Chaotikmind le 07/12/2010 19:08:26

Ps : je sous entendais qu'il aurait été sympa d'émuler le synthe plutôt que de faire du sampling..

Commentaire de VBtoTRASH le 08/12/2010 07:53:02

@pegase31

Ma vocation n'a jamais été de devenir un pro de le POO. Pourquoi ci, pourquoi çà ? Parce que ! Avant, c'était pas de la POO, maintenant c'est de la "pas bonne POO". Au diable la POO !

Trop compliqué ? Désolé, je ne sais pas faire plus simple.

Je fais cela pour m'amuser, et cela m'intéresse. Si ce n'est pas "digne" d'être placé sur ce site, et bien tu supprimes cette page, puisque je ne peux pas le faire moi-même.

@chaotikmind

Je suis musicien depuis ma plus tendre enfance, alors tu ne peux rien m'apprendre dans ce domaine. J'ai essayé plusieurs méthodes, et c'est la seule qui donne de bons résultats. Il existe une classe midi pour flash (Flash Midi SDK), mais çà reste du son midi bien pourrave.

Commentaire de pegase31 le 08/12/2010 08:24:21 administrateur CS

Si tu postes ta source ici c'est pour qu'elle soit mis en exemple pour les gens qui pourront y faire référence, mais aussi pour que tu puisses l'améliorer à l'aide de ceux qui pourront te donner de bons conseils. Ce qui est le but de cette section.
Je ne critique pas par plaisir de critiquer, mais pour te faire évoluer.

A toi de voir si tu veux avancer en programmation actionScript ou pas. Tu as du potentiel, sinon je ne me serais même pas donné la peine de faire une critique (surtout aussi précise).

Peg'

Commentaire de VBtoTRASH le 08/12/2010 09:34:06

@pegase31

Un logiciel, quel qu'il soit, n'est jamais parfait. J'ai bien compris ce que tu as voulu me dire, mais il y a plusieurs façons de faire, et j'opte pour celles qui me semblent le plus efficaces dans le contexte.

Une classe enfant as crée une évènement, et celui-ci est traité sur la classe appelante. Mais je trouve plus simple de la passer par une "Function", car je trouve cela moins lourd. J'ai commencé l'informatique en assembleur avec les premiers µP, et j'ai toujours gardé une certaine philosophie de la programmation. Pour les LED, les marqueurs ... tu as tout à fait raison, mais je ne voulais pas m'embêter. Ces LED ne servent à rien, mais j'en avais besoin pour contrôler visuellement l'occupation des canaux. Et puis, on a pas construit Paris en un jour ... ou même le petit village où j'habite.

Je supporte mal d'être critiqué, mais bon, je sais pertinemment que cette source est approximative, et non optimisé. C'était un premier jet. Par contre, il me serait utile de savoir si il existe une classe utilisant un timer de précision., car celui de flash est aussi pourri que celui de VB6. Quant au fait de déclarer la classe en MovieClip, c'est pour être tranquille. Il suffit ensuite d'ajuster.

Pour en revenir aux critiques, il serait préférable qu'elles soient plus constructives. Je poste ici pour avoir des conseils, ou des astuces pour fignoler le code, et j'en ai très peu. J'ai trouvé le moyen de faire des structures complexes, et cela peut poser quelques problèmes de compréhension.

Pour les variables, je n'ai pas trop le choix en ce qui concerne les sons.

Je vois que tu as pris le temps d'analyser le code, et je t'en remercie. Mais il ne faut pas voir que les défauts, sinon tout est moche.

Commentaire de BananaTree le 08/12/2010 13:12:56

Slt,

j'ai pas regardé le code (pas le temps de jouer).
qq trucs en vrac:

- pegase31, sans voir le code j'affirme que cette source est bien de l'object.
- Chaotikmind, la subdivision d'un ton est de 9 comas ;) (plus simple à comprendre je pense)
- VBtoTRASH, je pense que ce tuto devrait désintéresser: http://www.actionscript.org/resources/articles/1056/1/From-Fruity-Loops-to-Actionscript/Page1.html

bonne continuation les gars,
le niveau des sources remonte enfin,
ça fait plaisir :D

++

Commentaire de BananaTree le 08/12/2010 13:14:42

Chaotikmind, comme j'ai pas vu le code, je m'interroge sur la remarque vu que le piano est un instrument tempéré (faudra que je télécharge les as pour voir ça... un de ces 4)

Commentaire de VBtoTRASH le 08/12/2010 15:11:20

@BananaTree

M'intéresser, ou désintéresser qui ? Non, j'avais compris, merci du tuyau.

A plus

Commentaire de Chaotikmind le 08/12/2010 15:35:40 2/10

Desolé de la remarque un peu acide, le dsp c'est une de mes spécialités.
Anyway :  tu a une creation manuelle des notes :
>private const LA_0 :son_la_0 = new son_la_0();
>private const LAD_0 :son_lad_0 = new son_lad_0();
>private const SI_0 :son_si_0 = new son_si_0();
>private const DO_0 :son_do_0 = new son_do_0();

tu aurais très bien pu automatiser la creation de ces trucs dans un array/vector


Pour l'histoire du ton : 1 ton est bien divisé en 9 comma bien sur, pour les instrument non tempérés, sauf que ca ne définit pas mathématiquement le problème.
pour rappel le multiplicateur de fréquence pour passer d'un comma a l'autre: 2^(1/108)
Le piano est bien évidemment tempéré, donc pas très utile ici.

ps : je programme en c++ / assembleur,  je serais plus modéré que Pegase quand a la méthode de prog , mais je trouve quand même la structure du programme inefficace/douteuse.(cf exemple si dessus)

Commentaire de BananaTree le 08/12/2010 15:48:53

Juste par curiosité,
Tu crois que c'est possible de coder un séquencer non tempéré qui reconnais les modulations pour adapter automatiquement les comma en fonction des modes (min/maj)?

(j'ai mis 2 m et enlevé le s. suis vraiment nul en orthographe! )

Commentaire de Chaotikmind le 08/12/2010 15:59:39

la reconnaissance automatique du mode en cours me semble un peux hasardeuse ^^
enfin, c'est surement possible, quoi que certainement difficile.


le problème majeur si tu te dirige vers la synthèse des sons du piano, c'est que c'est franchement pas le son le plus simple à recréer, mais ca peux être fun a faire tout de même,
et ca doit pouvoir tourner en as3,  un objet par voie, alloué dynamiquement a chaque note pressée,  constitué de 4 waveguide, et hops la franchement je trouverais un intérêt a la source.

Commentaire de BananaTree le 08/12/2010 16:11:43

=> "certainement difficile"
Je dirais "monstrueusement" difficile.

VBtoTRASH, j'ai jamais utilisé l'api de sons dynamique de FP, mais pour compléter la piste proposée par Chaotikmind, il me semble que pixel bender peut aussi servir dans la manipulation des sons.
Anyway, just some thoughts...

Commentaire de VBtoTRASH le 08/12/2010 16:38:05

@ChaoTIKMIND

Connais pas le array/vector ! J'ai essayé de passer directement les sons dans un tableau, mais c'est refusé. Je n'ai pas dit qu'il n'y avait pas une autre solution, mais je n'ai trouvé que celle-ci pour l'instant.

Je tenais à préciser par contre, que les échantillons (Sampling pour les angliches !) ont été volontairement utilisés. J'ai une sainte horreur des sons synthétisés, comme le midi par exemple. Au début, j'avais tout mis en PCM, mais j'avais un fichier swf d'une taille 11 fois supérieur. Je me répète, mais je suis musicien, et plus précisément pianiste, alors les sonorités "pourraves", non merci ! Et je n'ai pas passé une journée à découper la gamme complète, pour maintenant changer d'avis, et de me retrouver avec des sonorités de piano désaccordé. Et je vais vous apprendre un truc, les cracks ! Un piano sonne faux. En effet, un ré dièse et un mi bémol, ce n'est pas la même note au violon ou au violoncelle, à un comma près. Je ne désire pas avoir un fichier swf tout petit, je veux un clavier qui dispose d'une sonorité de PIANO, pas de boîte à musique mécanique.

"... la structure du programme inefficace/douteuse."

J'ai commencé à programmer dans les années 1977. A d'autres, mon gars ! Sans me la péter, j'en connais au moins 100 fois plus que toi en programmation, et dans tous les langages.

@BananaTree

Je suis allé sur la page, et j'ai regardé le code. Le seul truc intéressant, c'est la lecture directe d'un fichier midi, mais cela, il y a bel lurette que je sais le faire. Quant à adapter la fréquence de l'échantillon suivant la note, je ne crois pas que la classe Sound en donne la possibilité. De plus, toutes les notes su piano ne se comportent pas de la même façon, suivant leur longueur, et leur texture. A la rigueur on pourrait tenter sur une quinte, voir un octave, mais ce n'est pas le but recherché. De toutes façons, le plugin Adobe du navigateur rame à mort, et le clavier n'a pas été conçu pour cette utilisation.

Par contre, si vous trouvez une classe timer de précision, comme RTimer, mais pour flash, je suis preneur.

Pas grave, je fais souvent des perles aussi !

Commentaire de VBtoTRASH le 08/12/2010 16:54:18

@Chaotikmind

Je n'avais pas souligné le tempéré, donc tu le savais !

Commentaire de pegase31 le 08/12/2010 17:59:05 administrateur CS

@Bananatree : alors à ce compte-là, l'actionscript est un langage objet, donc tout est de l'objet ... puisqu'on utilise des objets.
@VBtoTrash :  j'ai soulevé les points négatifs, car soulever les points positifs ne sert à rien (sinon ce ne serait pas une critique).
-Après devoir passer 8 paramètres dans un constructeur est peut-être plus simple pour toi, mais l'actionscript permet de faire plus efficace...
-Pour les sons, il suffit de les placer dans un tableau et inutile d'avoir une déclaration de toutes ces variables. De plus, il y a une fréquence dans tes modifications, donc une boucle ferait très bien l'affaire.

Au final, la source est fonctionnelle, mais pas efficace. Ce qui pose évidemment bien des soucis niveau optimisation et utilisation CPU.
Pour rappel : flash est un langage interprété qui ne bénéficie d'aune accélération matérielle. Donc autant réduire les ressources.

Peg'

Commentaire de Chaotikmind le 08/12/2010 18:53:13

>J'ai commencé à programmer dans les années 1977. A d'autres, mon gars ! Sans me la péter, >j'en connais au moins 100 fois plus que toi en programmation, et dans tous les langages.

T'a certainement commencer a programmer avant moi vu la date que tu avance, mais le source parle de lui même, je connais des gens qui programment depuis moins longtemps que moi , qui sont meilleurs (j'ai + de 15 ans de prog derrière moi quand même ..)

>J'ai essayé de passer directement les sons dans un tableau, mais c'est refusé.
assez contradictoire avec ta déclaration d'avant , je vois mal en quoi ca serait difficile de faire un array ou un vector d'instance de ta classe qui joue/manage le sample, c'est même plutôt basique en prog objet Oo

Commentaire de VBtoTRASH le 08/12/2010 18:54:49

@pegase31

Je commence à sérieusement regretter d'avoir déposé cette source ...

Oui, on ne peut pas critiquer les points positifs, c'est évident ! Mais je ne suis pas là pour entendre dire que je code comme un plouc ... ni pour qu'on me cire les pompes d'ailleurs.

Je peux contrôler la demande ressource du µp sur mon PC, et elle ne dépasse pas les 25% sur un simple c½ur vieux de 8 ans. Si vous testez sur un portable, c'est logique, puisque c'est un PC pour faire ses commissions sur Internet. Chacun fait son lit comme il dort, et comme tu le dis si bien, j'aurais pu passer une structure ou un tableau. Mais le problème n'est pas là. Le problème est que le timer n'est pas précis, et que le "démarrage" d'un son demande un délai non négligeable. Mais on s'en moque, puisque le clavier tourne très bien ainsi. De plus, je peux jouer un son à partir d'un delta t choisi  (En place, mais pas encore en service) pour l'attaque d'une note.

Quant à flash, la rapidité n'est pas son point fort, et d'ailleurs, je le redis encore une fois, je fais cela pour m'amuser. J'ai aussi remarqué, que dès qu'une source dépasse les vingt lignes, c'est la panique à bord. Vous n'avez jamais programmé en assembleur, çà se voit !

Et il faudrait que tu m'expliques pourquoi tu veux toujours avoir raison, même quand tu as tort ... ou que tu crois avoir raison en ayant tort.

Commentaire de VBtoTRASH le 08/12/2010 19:06:25

@chaotikmind

Tu sais écrire en Français sans foutre des mots d'angliche partout ?

Puisque tu sembles si fort, tu télécharges les sources, tu fais les corrections, et tu nous renvoies le tout. Je sais reconnaitre quand j'ai tort, mais je pense qu'un peu d'humilité ne vous ferait pas de mal.

Commentaire de pegase31 le 08/12/2010 19:16:12 administrateur CS

Qui cherche à avoir "raison" ? personne, je pense.

Je t'explique juste que ta source n'est pas adaptée à du flash .. tout simplement.
Mais toi qui fait du flash depuis quelques mois a forcément besoin de te recentrer sur la programmation de ce langage qui est très particulier comparé à d'autres (tente le Java, pour voir).

Donc améliore ta source et ferme donc notre clapet une bonne fois pour toute. Je serais le premier à te "critiquer" sur les points positifs de tes modifications ! ;)

Peg'

Commentaire de Chaotikmind le 08/12/2010 19:17:35

>Quant à flash, la rapidité n'est pas son point fort,
c'est pas moi qui vait dire le contraire, ceci dit il y a des synthétiseurs complet en AS3, la preuve qu'on peux quand même réussir à faire des applications gourmandes qui fonctionnent en temps réel en AS3

Commentaire de Chaotikmind le 08/12/2010 19:24:54

>Puisque tu sembles si fort, tu télécharges les sources, tu fais les corrections, et tu nous >renvoies le tout. Je sais reconnaitre quand j'ai tort, mais je pense qu'un peu d'humilité ne >vous ferait pas de mal.

Pas de problème, je charge le source .

>Tu sais écrire en Français sans foutre des mots d'angliche partout ?
non

Commentaire de VBtoTRASH le 08/12/2010 19:32:00

@pegase31

Alors là, oui je suis d'accord ! Mais pour la énième fois, je fais cela pour m'amuser. Fichtre, ôte moi de l'idée de faire autres choses que de la pub avec flash !

Je teste. Si çà marche, c'est bien, et si çà marche pas tant pis !

Allez, à plus

Eryc

@chatikmind

Je n'ai jamais dit que cela n'existait pas, mais en piano, je n'en ai trouvé que deux assez rikiki ! Oui, le gestion du clavier est lourde, mais j'ai tenté. Sinon, j'ai d'autres outils pour faire de la musique, et HEUREUSEMENT !

Salut

Eryc

Commentaire de pegase31 le 08/12/2010 19:39:35 administrateur CS

je reprécise ma phrase, qui, après relecture, pourrait être mal interprétée :

"Je t'explique juste que ta source n'est pas adaptée à [de la programmation sous] flash .. tout simplement."
C'est à dire que ta façon de coder ne s'intègre pas correctment dans la technologie et les possibilités offert par ce langage.

peg'

Commentaire de VBtoTRASH le 08/12/2010 19:45:12

@pegase31

J'avais bien entendu, merci.

Eryc

Commentaire de VBtoTRASH le 09/12/2010 09:32:25

@Tous

Il est possible de déclarer directement les notes dans un tableau en faisant de la sorte :

public var gamme:Array = new Array(new son_la_0, new son_lad_0, SI_0, new son_do_0, new son_dod_0, new son_re_0, new son_red_0, new son_mi_0, new son_fa_0, new son_fad_0, new son_sol_0, new son_sold_0 ...

Je travaille sur l'idée d'utiliser 8 notes de bases, et de calculer la gamme chromatique de l'octave. Si cela fonctionne, le poids du fichier sera divisé par 12. Mais dans ce cas, les sons seront téléchargés, et non résidents.

Commentaire de pegase31 le 09/12/2010 09:35:54 administrateur CS

pourquoi veux-tu faire des "new" ? Place-les simplement dans ton tableau au lieu de leurs affecter des noms de variable.

Peg'

Commentaire de VBtoTRASH le 09/12/2010 10:11:25

Salut,

Sans les "new", j'ai une erreur. Et ce ne sont pas des noms de variable, mais des noms de classe exportés pour ActionScript.

Eryc

Commentaire de VBtoTRASH le 09/12/2010 18:36:44

@Pegase31

Bon, j'ai suivi tes conseils, et j'ai déjà diminué de façon significative les lignes de code. Tu avais raison sur le fait que la programmation flash doit s'orienter sur les objets pour être efficace. Merci du conseil ! Je suis un râleur né, mais bon, il n'y a que les idiots qui ne changent pas d'avis.

Sinon, j'ai chopé un mal de crâne atroce.

Eryc

PS : Pour dupliquer une classe, il est impératif de sortir de la boucle d'itération, et d'utiliser l'instruction "new" à chaque fois.

Commentaire de Chaotikmind le 09/12/2010 22:18:31

J'ai réécrit un bout de ta source déjà, je sais pas trop quand ca sera finit, (j'ai du taff en masse)

juste pour indiquer ou j'en suit :

J'ai recreé l'interface en png, vu que je n'ai pas flash, et que donc je ne pouvais pas exporter les éléments d'origine en vectoriel (fxg).

Pegase m'a fait savoir hier en regardant ta source que tu utilisais probablement flash cs3 , si c'est le cas , ne soit pas surprit de voir certaine partie de code qui ne compileraient pas chez toi, j'utilise pas mal d'Embed et de Vector (aucune idée si ca passe sur cs3)

En rapport de ce que j'ai dit au dessus, j'utilise le sdk flex pour compiler, qui en plus d'être un outil officiel d'adobe, est gratuit (je dit ca vu que plein de gens misèrent a ne pas utiliser les dernières fonctionnalités de l'as3 à cause du prix des licences flash, alors qu'Adobe fournit le dernier compilateur gratuitement (il est open-source))

Tout ca pour dire qu'on peux faire du flash dernier cri sans débourser 1 centime. (avec un vrai IDE et débugger en prime)

Commentaire de VBtoTRASH le 10/12/2010 08:19:12

@chaotikmind

Ce n'est pas du CS3, mais du CS4 avec AS3 (Comme indiqué dans le titre). Oh, prends ton temps, je suis entrain de refaire une autre version plus orientée objet, et qui devrait être moins lourde, et plus compréhensible. J'ai aussi CS5, mais j'évite de migrer pour l'instant.

Je ne connaissais pas SDK FLEX, mais je pourrai le télécharger et voir ce que tu as fait de ton côté. Contrairement à toi, j'ai beaucoup de temps pour moi.

Commentaire de gremlins7 le 11/12/2010 15:55:26

Bonjour à tous !
Je suis extrêmement content de voir qu'une source suscite autant d'intérêt. Ce n'est pas arrivé depuis quelques mois.
J'ai absolument pas regardé le code, donc je ne ferais aucun commentaire à ce propos.
Je voulais juste dire à  VBtoTRASH qu'il ne faut surtout pas en vouloir à Peg, qui certes, ne s'y prend pas toujours bien (il a le talent de vexer les gens), mais qui fait des remarques toujours constructives. Il ne faut pas se vexer... Il n'est pas question de remettre en causes tes compétences en prog (comme j'ai pu le lire dans un comment), mais si tu écoute Peg, tu progressera beaucoup plus vite.
Tu dois comprendre que les habitués de ce site en ont marre des sources pourries ou inutiles qui ne font progresser personne. Là, tu viens avec un code fonctionnel (ce qui est déjà bien) et tu choisit délibérément de le soumettre à la critique. Comme dit Peg, ne t'attends pas à ce que ceux qui connaissent le sujet te disent que ce que tu as fait est génial, et que c'est le meilleur code pour le meilleur des mondes !!!
Tout le monde ici est dans une logique d'amélioration, la preuve: Peg t'a déjà fait gagner des lignes de codes et à mon avis ChaotikMind va te suggérer des corrections importantes. Au final, tu verra que ta source sera bien plus élaborée et bien plus performante et tu sera d'autant plus content d'avoir apporté quelque choses de sympa à la communauté. Et puis, si ta source n'était pas intéressante, tu n'aurais aucun commentaires (si ça peut te rassurer).
Parce qu'il faut bien que je ramène ma science aussi, mdr, juste en lisant les comments je me disait que l'on pouvait générer des sinusoïdes (pour les notes) à partir de l'algo suivant, comme je sais que tu es électronicien, ça doit te parler : en effectuant une transformée en Z d'une fonction de transfert oscillante (fait le calcul si t'amuse) on trouve :

y[n] = 2*cos(2pi.f)*y[n-1] - y[n-2]

Avec y[n] l'échantillon de sortie et y[n-1],y[n-2] les échantillons retardés, respectivement de 1 et 2 fois la période d'échantillonnage. f est la fréquence de la note. Pour les valeurs initiales de y[n-1] et y[n-2] c'est à dire lorsque n=1 :

y[n-1]=y[0]=
y[n-1]=y[-1]=-sin(2pi.f)

Voila si ça peut aider

Grems

Commentaire de VBtoTRASH le 11/12/2010 18:31:36

@gremlins7

Je n'en veux pas à Peg, il fait son boulot, et ses remarques sont pertinentes.

Le code est un premier jet, que j'ai soumis à la critique acerbe de la communauté de Flashkod. Depuis, j'ai amélioré le code, et il me reste à faire. J'ai ôté toutes les classes son, et je télécharge les 88 fichiers nécessaires au clavier, mais cela reste encore relativement long. Mon idée première était de faire un piano avec une sonorité de PIANO ... pas de crin-crin à musique. J'ai l'oreille d'un mélomane, et la moindre imperfection me fait hérisser les cheveux. Merci pour ce rappel de mathématique que je vais garder précieusement, mais pour l'instant j'optimise le code de gestion, et la version 2 aura toujours ses 88 échantillons. Il me sera aisé par le suite (je le souhaite !) de créer une classe de synthèse de son, ou je vais exploiter à fond la classe "Math". La version en cours est plus stable, et non sujette aux mauvaises manipulations, mais il ne m'est guère facile de faire simple et efficace à la fois. Pour conclure, ce filon me passionne, et il y aura une suite, puisque je compte y inclure d'autres sonorités.

Pour en revenir aux remarques, il y a une façon plus courtoise de les faire, à moins que ce mot soit désuet de nos jours.
Cela m'irrite fortement !

Eryc

Commentaire de Chaotikmind le 11/12/2010 18:55:05

Juste pour info, mais le niveau de souffle dans les samples que tu as est assez élevé,
juste pour dire que ca mériterait un petit denoising avant compression en mp3.

J'avais des samples de steinway dans un coin, mais impossible de remettre la main dessus >.<

Commentaire de VBtoTRASH le 12/12/2010 09:47:51

@chaotikmind

Oui, j'ai remarqué. Je vais les filtrer.

Pour le Steinway, je suis partant. Fouille bien tes disques.

Eryc

Commentaire de VBtoTRASH le 12/12/2010 12:22:40

@gremlins7

J'ai compris la subtilité sur ce que tu m'as patiemment et longuement expliqué. Certes, cela chamboule le code en place, mais petit à petit le vieux singe grimaçant retrouve le sourire.

Eryc

Commentaire de Chaotikmind le 12/12/2010 12:49:45

Je les ais retrouvé, je les intègrerais du coup.

Commentaire de gremlins7 le 12/12/2010 12:57:02

AH La POO ! quand tu as saisi le truc, après tu peux plus t'en passer !!!
Je suis content de t'avoir redonner le sourire, ça vaut mieux que n'importe quel merci.
Si tu as besoin de moi n'hésite pas à m'envoyer des messages, je me ferais une joie de t'aider, dans la mesure du possible car j'ai pas beaucoup de temps pour moi.

Grems

Commentaire de VBtoTRASH le 13/12/2010 18:31:43

@tous

Je vais vous avouer un truc. Je n'avais rien compris à la POO, et grâce à vos nombreuses critiques constructives, j'ai enfin pigé le truc.

Confirmation, tout est objet, sans exception. Partant de ce principe, il suffit de créer se objets et de les emboîter dans un ordre chronologique bien établi. J'avais tendance dans la première version, a tout relier à la classe de base. Cela fonctionne, mais n'est pas très en règle avec le langage flash.

@gremlins7

Tu m'as ouvert les yeux. Merci !

@chaotikmind

J'ai pu récupérer sur Interpoub deux lots d'échantillonnages pour piano, un Steinway et un Playel. Ils manque la moitié des notes, mais je suis entrain de refaire les gammes complètes avec Au de qui vous savez. Le souffle des échantillonnages de la première version ne sont audibles que dans les accords (Ou arpèges pour les puritains), mais je filtrerai le bruit de ces derniers. Il ne faut pas oublier que l'encodage mp3 est destructif, et qu'il y aura toujours du bruit. J'ai essayé d'attribuer des sons en PCM, mais la classe "Sound" les refuse. En passant les sons en CBR 320 (Le mode VBR cause des erreurs), c'est plus joli, mais çà rame.

En ayant supprimer une bonne partie des lignes de programme, je ne suis plus qu'à 20% de ressources µP au lieu de 25%.

Je pense que d'ici une bonne grosse semaine, la version 2 sera opérationnelle.

@pegase31

Je ne pense pas que tu puisses critiquer cette prochaine version ... bien que ...

Eryc

Commentaire de Chaotikmind le 13/12/2010 20:14:24

on comparera les 2 versions ^^

Je doit t'admettre que je n'ai pas vraiment suivis la même voie,  je décompresse les mp3 au chargement et je fait le mixage manuellement (je suis en train d'ajouter une reverb maison la)

j'ai rencontré plusieurs prob : ma première version ne consommait pas moi de 1.2 go de mémoire.... et tournait très difficilement , j'ai donc opté pour l'utilisation de samples mono,  et après pas mal de bidouillage ca tourne presque comme il faut.
a peu pres 25% processeur sur mon pc (q9550)

>J'ai essayé d'attribuer des sons en PCM, mais la classe "Sound" les refuse.
Oui , la "seule" alternative serait de charger les wav toi même, ce qui est parfaitement faisable vu la simplicité du format ceci dit.

Autre solution potentielle :
j'ai étudier un peu une application flash dont les sources ne sont pas dispo (et dont je tairais le nom)  à priori il ont trouvé un moyen d'inclure des samples brut dans leur swf, donc y'a moyen (les données incluses dans le swf sont de type Bytearray, ce qui permet d'inclure n'importe quoi)
Reste à savoir si c'est une feinte du langage qui permet ca, ou bien s'il on utilisé un compilateur légèrement modifié, vu qu'a m'a connaissance il n'y a pas d'objet dans la librairie qui puisse être de classe bytearray (bien que la spécification du langage ne l'interdise surement pas)

Commentaire de VBtoTRASH le 18/12/2010 16:23:27

@vis à la population de flashkod

Sur le site "http://www.creaza.com/frontpage" tourne plusieurs applications flex. On peut faire de la musique, du dessin, et d'autres trucs.

Si vous arrivez à copier et à décompiler une de ces dernières, vous allez vous retrouver avec pas moins de 990 fichier as. J'ai essayé de compiler ce que j'avais récupéré, mais je me retrouve avec une multitude d'erreurs. Cela est sans doute dû à la version du compilateur lui-même, mais pour ceux que cela intéresse, il y a de quoi s'amuser. Personnellement, j'avoue que je rame devant cette nuée de classes.
Là, c'est de la POO en overdose !

@chaotickmind

Sous CS4, il y a bien une classe "ByteArray" pour charger des fichiers en binaire. J'utiliserai celle-ci pour pouvoir lire directement les fichiers midi, ce qui simplifiera la génération de mes fichiers xidi (midi xml).

J'attends avec impatience ta version, car pour l'instant, je ne suis pas satisfait de ma dernière version. Par exemple, le fait de couper un son peu de temps après son démarrage, provoque un clic. J'ai bien essayé de baisser le volume à 0 avant de stopper le canal, mais rien n'y fait. J'ai pu remarquer ce même problème sur d'autres applications similaires.

La réverbération ? Facile ! Il suffit de démarrer le même son sur deux canaux différents, avec un delta t variable.

Sinon, BananaTree m'avait donné ce lien "http://www.actionscript.org/resources/articles/1056/1/From-Fruity-Loops-to-Actionscript/Page1.html". Certes, le son n'est pas de grande qualité, mais le mec utilise le calcul pour refaire les gammes. Si cela peut t'intéresser ...

Commentaire de Chaotikmind le 18/12/2010 17:31:17

"J'attends avec impatience ta version, car pour l'instant, je ne suis pas satisfait de ma dernière version. Par exemple, le fait de couper un son peu de temps après son démarrage, provoque un clic. J'ai bien essayé de baisser le volume à 0 avant de stopper le canal, mais rien n'y fait. J'ai pu remarquer ce même problème sur d'autres applications similaires"

Waip tout a fait normal, je n'ai pas trop ce problème vu que le mixage est manuel chez moi.


pour ce qui est des Bytearray , je me suis documenté entre en temps, j'ai testé , et effectivement ca marche comme prévu, j'ai donc importé tout les sons en wav.


"La réverbération ? Facile ! Il suffit de démarrer le même son sur deux canaux différents, avec un delta t variable."
euh non..  si ton delay est variable tu aura une sorte de phaser

il faut 2 comb filter et 2 allpass filter pour une réverbération (c'est le minimum vital d'autant que je me rappelle)


je vous upload une preview de ce que ca donne (la reverb est un beaucoup trop métallique pour l'instant)

http://chaotikmind.synigen.biz/Piano.7z


alors ce qui est implementé :
-Lecture des sample avec interpolation lineaire (j'utilise plusieurs fois le même sample pour plusieurs touches du clavier)
-On peux jouer à la souris comme avant, avec 2 petites différences, la hauteur à laquelle on clique sur la touche change le volume, et la longueur du click est prise en compte aussi.
-Les touches a2z3er5t6y7u correspondent à la première octave du clavier (j'ai pas fait le reste, ca va venir)

voila pour l'instant c'est à peu près tout,  
malheureusement on ne peux pas désactiver ou régler la reverb pour l'instant, ca viendra aussi.

si quelqu'un veux les sources avant que j'ai finit, dites le moi je zipperais tout ca

Commentaire de VBtoTRASH le 19/12/2010 08:56:59

En effet, le résultat est convainquant, et les sons obtenus d'une très bonne qualité, proche d'un piano conventionnel. Mais il y a un petit bémol. En effet, entre l'appui sur une touche, et le "démarrage" du son correspondant, il existe un temps non négligeable. J'ai aussi ce problème, mais ce temps de réaction est plus court. Par contre, le poids du fichier swf est relativement élevé. Pourquoi n'utilises-tu donc pas un échantillon par octave, ou par quarte ?

Sinon, chapeau bas, c'est du bon boulot, et je ne vois plus l'intérêt de faire progresser erypiano.

Je suis intéressé par les sources, car je suis curieux de nature. Pour que Monsieur Tout-le-Monde puisse décompresser ces dernières, utilise autre chose que 7z.

Pour la réverbération, tu chipotes. Un delta_t variable pour l'effet, mais constant.

Encore un truc : La réverbération n'est pas utile pour un piano. On n'est pas à l'église, ou dans les catacombes de Paris.

Commentaire de Chaotikmind le 19/12/2010 12:29:13

Ok je vais mettre à dispo les sources actuelle, mais il faut bien garder à l'esprit que c'est pas vraiment finit.

Pour la reverb je suis pas vraiment d'accord, juste ma reverb la est pas d'assez bonne qualité pour avoir un réel intérêt, j'entends par la juste pouvoir donner une ambiance très légère  pour que le son (qui a surement été enregistré dans une chambre anéchoîque) soit moins froid.

Pour la latence, malheureusement flash ne supporte pas une taille de buffer en dessous de 2048, donc y'a rien a faire >.<

Sur ta version tu peux tester quelque-chose -> la compression en mp3 ajoute un blanc en début de sample, décale ta position de lecture de 20-30 millisecondes en avant, tu devrait te retrouver avec la même latence que moi (je pense)

Sinon franchement le type qui est intéressé par la source, ca veux dire qu'il programme plus ou moins, s'il n'est même pas capable de décompresser un 7z tu sais ce que j'en pense? ;)

La source actuelle :
http://chaotikmind.synigen.biz/Piano_src.7z

Outils utilisés :
-FlashDevelop 3.3.2
-Adobe Flex Sdk 4.1.0.16076


PS : tous mes calculs sont fait pour du mono, mais il est assez trivial de convertir pour utiliser des samples stéréos, les valeurs pour la gauche et la droite sont alternées en stéréo , de toute façon il est facile de trouver des docs détaillées sur le format sur le net.

Commentaire de VBtoTRASH le 19/12/2010 13:06:06

Je sais très bien, mais comme je sais décompressé du 7z, normalement je peux deviner que ce n'est pas fini.

Je peux en effet décaler le point de lecture sur le mp3 ... il me vient une idée ! Et si j'utilisais cette combine pour "éteindre" ma note en positionnant le pointeur en fin de buffer. Je vais essayer !

J'ai téléchargé Flex SDK. Ouais, c'est beaucoup plus artisanal comme développement, ce qui explique cette abondance de fichier .as quand je décompile.

Bon, je vais télécharger tes sources.

Flash Builder ne convient pas ? Sinon, je crois en avoir un dans un coin de disque.

Commentaire de Chaotikmind le 19/12/2010 13:24:20

Aucune idée, j'utilise aucun des outils commerciaux adobe

Les raisons majeures étant :
-Flashdevelop est largement supérieur en tant qu'IDE  à toutes les saloperies adobe
-Le sdk flex permet autant de faire du flash / air / flex (c'est le même langage on se demande bien pourquoi il faudrait des outils différents , encore une joyeuse idée marketing de chez adobe XD)

Commentaire de VBtoTRASH le 19/12/2010 18:12:05

En effet, cet outil ma parait passionnant. J'ai commencé à regarder tes sources, et on peut dire que la syntaxe est soignée ... mais double bémol, j'ai une sainte horreur de l'angliche ! Premièrement, parce que les Angliches nous cassent les noisettes depuis la nuit des temps, et qu'ils nous ont cramé Jeanne d'Arc ... et que j'ai fait Allemand en première et dernière langue. Même si c'est Américain, çà ne change rien !

J'ai testé ce que je t'avais dit précédemment, et cela ne change rien. Le fait de couper le décodage mp3, quand l'amplitude du signal est élevée, génère un "clic" désagréable. J'ai bien essayé de modifier le son par SoundTransform, mais le temps de réaction est trop lent, donc inefficace.

Demain il fera jour !

Commentaire de top30 le 04/01/2011 13:51:16

http://www.flashkod.com/codes/CONCEPT-BASE-POO_52678.aspx
Une petite démo faut mieux qu'un long discours.

Je prendrais le temps de t'écrire plus tard...

Commentaire de top30 le 04/01/2011 19:40:20

Ma source n'avait QUE le but de t'aider. Ni de refaire ton taf, ni de le copier.
Moi perso je serais pas passer par un sous clip "octave"...

C'est juste pour te montrer que Peg a raison. Tu utilises un language "POO" sans bénéfier réellement de ce qu'il te permettrait d'apporter. Si tu veux un autre exemple, simple: ton "slider" de tiempo et et volume sont absolument identique à part du "label". D'où le besoin d'en créer un génerique dont tu utilises deux instances. Un pour le tiempo et un pour le "volume". Comme ca de facile:

var sliderVolume :MonSlider= new MonSlider("volume");
sliderVolume.addEventListener( "change", onSliderChange );
addChild( sliderVolume );

var sliderTiempo :MonSlider= new MonSlider("tiempo");
sliderTiempo .addEventListener( "change", onSliderChange );
addChild( sliderTiempo );

private function onSliderChange( $e:Event ):void{
   switch( $e.target ){
      // $e.target étant le "slider", et "value" de 1 à 0 selon le slide...
      case sliderVolume : this.setVolume( $e.target.value*100 ) ; break ;
      case sliderTiempo : this.setTiempo( $e.target.value*120 ) ; break ;
   }
}

Tu as le dont, à mon avis de compliquer le simple. Vu que t'as pas encore "piger" les avantages de l'AS3 et l0interface Flash. Par contre tu as aussi de bonne idée, un chargeur XML avec des handlers d'évèment different définit à travers une ID passée à la fonction "load" c'est pas con... Tu regroupes plusieurs instance en une seule, le but de la POO étant l'inverse. En simple:

class MonChargeurXML
{
   fonction MonChargeurXML(){
     this._loader= new URLLoader();
     // Code habituel...
    this._loader.addEventListener( "complete", this._parseHandler );
   }


   function get xml():XML{ return this._xml }
   private var _xml :XML ;


   function load( $url:String ):void{
      this._loader.load($url);
   }

    function parseXML():void{
      throw new Error("Sans étendre la classe, ne fera rien que de jeter des erreurs");
   }

   private function _parseHandler( $e:Event ):void{
      this._xml= new XML($e.target.data);
      this.parseXML();
   }
}


class MaConfigXML
extends MonChargeurXML
{
   public function MaConfigXML(){};

   public override function parseXML():void{
       // Faire ce que tu veux avec to XML
       trace( this.xml );
   }
}


class MaPartitionXML
extends MonChargeurXML
{
   public function MaPartitionXML(){};

   public override function parseXML():void{
       // Faire ce que tu veux avec to XML
       trace( this.xml );
   }
}

Ca c'est de la POO...
Tu devrais essayer de revoir ta source car je pense que l'idée est bonne et que tu as un bon niveau.

Commentaire de top30 le 04/01/2011 20:50:14

J'ai modifier ma source pour qu'elle puisse réagir au touches du clavier. Comme un piano !
Mais c'est juste du vite fait.. Pour te monter, faut pas déconner quand même !

Commentaire de VBtoTRASH le 05/01/2011 08:12:02

@Top30:

Salut,

ErySoft n'a aucune prétention, et n'existe pas pour se faire du pognon. Je mets à disposition des idées, et des connaissances qui me sont acquises ... sans plus.

Pour en revenir à la POO, je suis désolé, mais quand j'étais en IUT GE, les premiers ordinateurs étaient considérés comme des boites mystérieuses. J'ai donc commencé "la programmation" avec des instructions allant de 0x00 à 0xFF, voir avec les 16 instructions du MC14500, le premier ICU de Motorola qui tourne encore sur certaines machines. De ce fait, on se forge une philosophie de codage bien différente de celle d'aujourd'hui.

Je prends bonne note de tout ce que tu m'as dit, et je vais donc essayé de penser en POO pour la prochaine version. Merci d'avoir fait évoluer ton clavier, je pourrai ainsi avoir une bonne base de départ.

A plus

Eryc

 Ajouter un commentaire


Discussions en rapport avec ce code source dans le forum

Piano à 61 touches [ par Niamoi ] Je comprend pas pourquoi je ne peux pas télécharger le piano virtuel...G créer un compte membre pour le télécharger mais sa ne marche pas<img src="htt Découverte de l'AS3...pas gagné [ par Neferieb ] Bonjour,Je suis un peu dérouté en ce moment car je découvre l'AS3 et je reste perplexe quant au manque d'info pour réaliser des applications web plus php et flash 9 en AS3 [ par tranber78 ] Ben voilà j'aimerai avoir un script pour faire dialoguer flash et php en AS3 pour des chargement dynamique de vidéos, de sons, d'images, etc...Merci à Flash 9 / AS3 + Socket MySQL question [ par _benjy ] Salut @ tous...Bon j'imgine que certain d'entre vous sont au courant de la publication de Flash 9 Alpha. Perso je l'ai recup av hier, et autant le dir Compatibilité code flash8 ===> flash cs4 [ par sachie ] Bonjour à tous!une question me turlupine!est il possible de récupérer un fichier .fla réalisé sous Macromedia Flash Professional 8 sous Flash cs4 ?Log AS3- FsCommand [ par Maitrespl ] Bonsoir a tous!Je viens récement de passer de l'AS2 à l'AS3 et j'avoue que j'en bave!Je suis en train de dévelloper un programme qui fonctionne en loc flash et base de donnée sql AS3 [ par delminator ] salut tout le monde  je cherche un tuto pour les interactions " flash / php / base de donnée sql " en AS3existe t il aussi des softs pour simplifier l importer une animation en flash As3 dans un swf as2 ? [ par nackdawa ] Bonjour a tous :)J'ai une petite question piege, qui est dans mon titre. Comment faire pour lire une animation faite sous flash en mode As3 dans un lo Flash chargement dynamique txt et parse avec css externe (AS3) [ par thewildwilliams ] Salut à Tous g un soucis avec AS3, J'ai une un swf sur un site perso formatté en css, le swf charge dynamiquement un texte "playlist" et parse un css CS4/AS3 : [ par mouahaha ] Bonjour à tous !Je me suis récemment mis à l'AS3, et à Flash CS4 (je regrette d'ailleurs de ne pas m'y être mis plus tôt ^^), et je m'y fais assez bie


Nos sponsors


Sondage...

Comparez les prix

CalendriCode

Mai 2012
LMMJVSD
 123456
78910111213
14151617181920
21222324252627
28293031   

Consulter la suite du CalendriCode

A découvrir



 
Développement réalisé par Nicolas SOREL (Nix) avec l'aide de : Cyril DURAND et Emmanuel (EBArtSoft), Merci à Vincent pour ses précieux conseils.
CodeS-SourceS.com© Toute reproduction même partielle est interdite sauf accord écrit du Webmaster
CodeS-SourceS.com© est une marque déposée tous droits réservés

Google Coop CodeS-SourceS Google Coop CodeS-SourceS
Temps d'éxécution de la page : 1,529 sec (3)

Nous contacter | Annoncer sur CodeS-SourceS | Mentions légales