Contenu | Rechercher | Menus

Annonce

Si vous rencontrez des soucis à rester connecté sur le forum (ou si vous avez perdu votre mot de passe) déconnectez-vous et reconnectez-vous depuis cette page, en cochant la case "Me connecter automatiquement lors de mes prochaines visites".
Test de l'ISO d'Ubuntu francophone : nous avons besoin de testeurs pour la version francophone d'Ubuntu 14.04. Liens et informations ici.

Attention, une faille de sécurité dans bash a récemment été rapportée, il est recommandé de mettre à jour son système (plus de détails)

#1 Le 09/02/2014, à 05:15

temps

lm3jo en deb version 1.1.1-4

Bonjour,

Depuis le début, je maintiens le piano virtuel lm3jo sous la forme d'un répertoire.
Dans ce répertoire le piano virtuel change de nom selon que je l'ai écris sous SDL 1.2, Qt5 ou, Gtk3
Afin que l'application soit plus facile à utiliser, je viens de créer une première version en deb (la version SDL car sous qt5 les dépendances changent entre la 13.10 et 12.04)

La version a pour dépendance sox, le paquet fonctionne très bien sur mon P.C. et sur le P.C. d'un ami qui a bien voulu tester.
Je suis à la recherche de testeurs de manière à savoir si le paquet installe bien l'application lm3jo, nommé AbadieJoueurDeVoix, correctement.
Le lien de téléchargement est ici http://www.letime.net/vocale/paquet_deb … DeVoix.deb

Pour rappel, les sons de base des touches du piano sont facilement interchangeable et peuvent être construits à l'aide de fichiers texte.

Cordialement

Dernière modification par temps (Le 21/02/2014, à 08:01)


Parce que l'USB bootable est le support des systèmes experts,
Parce que l'USB bootable contient sa propre image au démarrage.
L'USB bootable permet de créer un monde à la dimension de son imagination

Hors ligne

#2 Le 13/02/2014, à 13:55

temps

Re : lm3jo en deb version 1.1.1-4

Bonjour,
Je viens de sortir une nouvelle version de Lm3jo http://www.letime.net/vocale/paquet_deb/lm3jo.deb
Cette nouvelle version n'utilise plus la fonction mathématique qui permettait de rendre le format audio.jo compatible avec les carte audio actuelles. J'ai remplacé cette fonction par des tableaux ou tous les cas possibles sont inscrit. Cette technique bien qu'elle rende cette partie de l'application presque 5 fois plus lourde, permet d'avoir un résultat toujours identique (forme des courbes qui étaient parfois déformées) et permet aussi d'avoir une application beaucoup légère en fonctionnement, faible consommatrice ressources processeur.
Pour rappel l'application se lance en ligne de commande en entrant :
lm3jo
Il est préférable de se placer dans un répertoire, car l'application crée des fichiers wav de manière à ce qu'ils puissent être récupérés.
Le paquet Lm3jo.deb est destiné à ubuntu 13.10 à cause des dépendances qt5, ne se trouvant pas sous 12.04

Cordialement

Dernière modification par temps (Le 25/02/2014, à 07:30)


Parce que l'USB bootable est le support des systèmes experts,
Parce que l'USB bootable contient sa propre image au démarrage.
L'USB bootable permet de créer un monde à la dimension de son imagination

Hors ligne

#3 Le 27/02/2014, à 19:12

temps

Re : lm3jo en deb version 1.1.1-4

Bonjour,
Suite à la sortie de la version  la Lm3jo 1.1.1-5 qui est ici http://www.letime.net/vocale/paquet_deb/lm3jo.deb

J'ai mis une vidéo présentant le graphisme  , et j'ai commencé  écrire un petit tutoriel ci-dessous

How_to_lm3jo

Lm3jo est écrit pour la version 13.10 et dérivées d'ubuntu.
L'adresse actuelle en attendant le ppa est http://www.letime.net/vocale/paquet_deb/lm3jo.deb
en utilisant qapt-deb-installer .

Une fois installé il faut ouvrir un terminal.
Pendant son fonctionnement lm3jo crée des fichiers audio de manière à ce que les créateurs de nouveaux sons puissent les récupérer.
De manière à ne pas créer des fichiers audio dans une zone limité il est conseillé de créer un répertoire et de se placer à l'intérieur
sudo mkdir mysound
cd mysound
Pour lancer l'application, il faut entrer dans le terminal
lm3jo
Une fois lancée l'application s'ouvre sur un clavier 78 touches.

1) Mode piano virtuel (Acapela, Flute, Drum, basse, Guitare, saxo, Orgue, piano, fun, violon, Guit.Elec., Nature)

12 boutons au dessus permettent de changer les sons se trouvant derrière le clavier 78 touches soient 936 sons de base clavier.
Les sons peuvent être joués à la sourie, et au clavier qwerty. Le clavier qwerty reprend les 26 touches du clavier du bas, il est possible de jouer plusieurs touches en même temps.
Les Bibliothèque de base sont en cours de construction et plusieurs des sons sont encore expérimentaux.

2)  Mode joa à jo

Le mode joa à jo sert à créer facilement sa bibliothèque de base de 2704 sons
Ses bases pourront être partagées ou utilisées à convenance par chaque créateur.
Pour créer un son au format jo, il faut cliquer sur le bouton joa à jo
Il faut ouvrir un tableur et crée deux colonnes composées de valeurs entre 30 et 220.
La première valeur sert à indiquer l'amplitude du front acoustique.
La deuxième valeur sert à indiquer la durée du front acoustique en 1/44100 seconde.
Dans la fenêtre ouverte de lm3jo, il faut cliquer sur le premier onglet et faire un copier/coller des deux colonnes dans le fichier texte qui s'ouvre.
Ensuite il faut clique sur le deuxième onglet et donner un nom au fichier audio créé.
Ce nom doit être composé de deux lettres sensibles à la casse. En exemple aA ou aa ou Aa ou AA sons 4 fichiers différents.
Pour finaliser, il faut cliquer sur le troisième onglet qui crée le fichier et donne une première écoute de sa création.
Attention les sons dépendent des lois physiques, des lois physiologiques, et de ce que le cerveau veut bien entendre (l'entendement).
Pour l'entendement, en exemple si nous prenons une voix humaine et que nous enlevons la partie des sons placée juste avant un front de grande amplitude, le cerveau refusera de reconnaître la voix humaine et identifiera fort probablement un son de piano. Un conditionnement automatique des cas possibles très fort est présent en acoustique.



3) Mode composition mix

La bibliothèque interchangeable de premier niveau est composée de deux lettres sensibles à la casse, (en exemple ab, aB, Fj...) soit 2704 sons.
En premier il faut cliquer sur le bouton Mode composition mix. La fenêtre s'ouvre avec à sa droite des bouton d'ouverture de fichiers textes.
Dans ces fichiers textes pouvons associer les sons en créant des suites, pour reprendre l'exemple : abaBFj
Les bouton à droite permettent la lecture de ces fichiers textes.
La ligne 1 est pour une piste.
La ligne 2 est pour 2 pistes, la ligne 1 associée à la ligne 2, ainsi jusqu'à 16 pistes.


4) Mode lecture texte

Pour ouvrir le mode lecture texte, il faut cliquer sur le bouton portant le même nom.
Nous trouvons dans la fenêtre qui s'ouvre que deux boutons.
Le premier bouton sert à enter le texte que l'on veut écouter.
Le deuxième bouton sert à la lecture du texte entré.
Actuellement cette fonction est en construction sur la langue française.
Il est prévue plus tard d’ajouter d'autres langues.

5) Mode format Adn

Le mode format Adn est une des meilleures représentation du format abadie jo
Pour l'utiliser, il faut cliquer sur le bouton
Avec seulement trois octets nous pouvons produire un grand nombre des marteaux acoustiques.

Pour ouvrir la fenêtre il faut cliquer sur format Adn
La fenêtre Adn est composé de 8 boutons pour la création, d'un bouton pour lire le fichier audio créé et d'un bouton pour effacer le fichier audio.

Le premier bouton sert à créer les marteaux acoustiques.
Il faut entrer 3 valeurs sans qu'aucune ne dépasse 220.
La première pour indiquer la variation d'amplitude.
La deuxième pour indiquer la variation de durée
La troisième pour indiquer la durée totale.
Le deuxième bouton sur la même ligne pour écrire une fois le son créé dans le fichier audio.

Le troisième bouton sert à créer la licorne.
Il faut entrer 9 valeurs.
le quatrième bouton sert à créer le fichier son créé dans le fichier audio

Le cinquième bouton sert à créer le mariage
Il faut entrer 19 valeurs.
Le sixième bouton sert à créer le fichier son créé dans le fichier audio

Le septième bouton sert à créer la vinaigrette
Il faut entrer 4 valeurs.
Le huitième bouton sert à créer le fichier son créé dans le fichier audio

Le neuvième bouton sert à écouter le contenue du fichier audio

Le dixième bouton sert à effacer le contenue du fichier audio

Bonus Lm3jo
Une suite de 50 fronts qui peuvent être pilotés avec des curseurs.
Un curseur pou la force, un curseur pour l'amplitude et un curseur pour la durée.

Dernière modification par temps (Le 28/02/2014, à 09:14)


Parce que l'USB bootable est le support des systèmes experts,
Parce que l'USB bootable contient sa propre image au démarrage.
L'USB bootable permet de créer un monde à la dimension de son imagination

Hors ligne

#4 Le 22/03/2014, à 23:17

temps

Re : lm3jo en deb version 1.1.1-4

Bonjour,
J'annonce la sortie de la version 1.1.1-9, toujours à la même adresse.
Cette version est accompagnée de son fichier sources
Une fois le répertoire décompressé, Il faut lire le fichier lisez_moi pour avoir le tutoriel d'installation du makefile

Les prochaines étapes sont la création d'une bascule de bibliothèque contenant chacune 2704 sons, regrouper les applications adn en une seule ;  alléger le code Qt en regroupant les 12 fenêtres des différents piano virtuel en une seule et ce qui devrait peut-être fait en premier, créer un éditeur de partitions au format adn.
Dans l'application lm3jo, il y a la démonstration que nous pouvons reconstruire tous les sons avant mixage avec 4 formes de base (bien que le marteau soit une forme particulière de la vinaigrette). L'idée est d'ajouter une fonction qui permet d'écrire directement dans un fichier texte, des suites de ces 4 formes de base en donnant à chacune d'elle ses particularités. En exemple à chaque lecture de la lettre m le fichier lira les 3 octets suivants ou plus si ont crée des marteaux acoustiques plus évolués, pour créer un marteau acoustique. La partition serait composée de M (les valeurs de m)V(les valeurs)A(les valeurs du mariage)L(les valeurs de la licorne). Ce qui donnerai des partitions musicales de la forme :
M 1 1 100 M 20 200 20 80 65 20 52 14 L ....
Quelques dizaines ou centaines d'octets donnant des Go de musique, on peut même penser que les artistes se créeront des bases constituées de séries qu'ils pourront rappeler par un simple lien plusieurs fois dans la même partition.

Le projet est en pause, ce jour, car je travaille sur la création de sources  avec la communauté debian. La peitite boucle du bash qui permet de changer le nom du fichier audio sortie et par la même le maintient continue des touches sur n'importe quel son est donc aussi en attente.

Le projet va avoir une base qui pourra s'adapter soit à une fenêtre graphique sous Qt, soit à une fenêtre graphique SDL pour faibles ressources, soit sans écran à un clavier USB plus de 40 touches forme piano sans écran pour créer des sons directement par imagination sans forme d'imitation (une porte ouverte vers le casque audio neuronal)

En construction une bibliotheque de 8 octets pour compositeur et les jeux sous linux soit ( "256 puissance 8" cas de formes acoustiques construitent sous adn). la particularité de cette bibliothèque est sa très grande qualité acoustique, sa légèreté et son poid seulement 8 octets (après conversion ASCII binaire pour pouvoir écrire les 8 valeurs (de 1 à 256) facilement au clavier)


Parce que l'USB bootable est le support des systèmes experts,
Parce que l'USB bootable contient sa propre image au démarrage.
L'USB bootable permet de créer un monde à la dimension de son imagination

Hors ligne

#5 Le 06/04/2014, à 11:01

temps

Re : lm3jo en deb version 1.1.1-4

Bonjour,
Afin d'obtenir une meilleure compatibilité avec les outils du moment, j'ai créé une version qt4 64 en téléchargement ici
Cette version contient la BAUL (Bibliothèque Acoustique Universelle pour Linux)
La baul est constitué d'une petite application en C et quelques fichiers textes assez léger contenant les lignes des différents états d'équilibre.
Cet outil sert à créer des fichiers audio sans limitation de durée à l'aide d'une base tenant dans 14 octets
L'avantage d'utiliser la baul au travers de LM3JO provient du fait que lm3jo permet de modifier les lignes des états d'équilibre et ensuite d'entendre ses propres créations.
En exemple en manipulant quelques jours la baul, il est facile de créer ses mélodies et de les exporter avec seulement quelques octets en fournissant si nécessaire des fichiers textes modifiés de la baul.

Cordialement


Parce que l'USB bootable est le support des systèmes experts,
Parce que l'USB bootable contient sa propre image au démarrage.
L'USB bootable permet de créer un monde à la dimension de son imagination

Hors ligne

#6 Le 12/04/2014, à 07:44

temps

Re : lm3jo en deb version 1.1.1-4

Bonjour,
Je modifie la BAUL aujourd'hui, pour lui ajouter une meta forme le "D" (meta en opposition aux formes de bases précédentes) dédiée au sons des voyelles de la voix humaine (les consonnes se créent facilement avec les formes de bases). Cette forme est a durée de front constante par fun de la maitrise et à palier constant car je n'arrive pas encore à coder les paliers avec une boucle et une variable et j'ai donc utilisé un switch pour avoir ces paliers, une des caractéristiques qui crée les formes de la voix humaine
Voici les lignes de code dans liadn qui créent la forme D
Peut-être aussi je modifierai le nombre d'octets de la BAUL pour passer à 16 octets de manière à augmenter le nombre de cas de séries de formes.
Cordialement

int
fonctionpourD (int amplitude1, int amplitude2, int nbdepoints1, int nbdepoints2, int varamplitude1,  int durer1)
{/**ouvre le1**/

/*securite**/
if (durer1 > 1000)
{
durer1 = 1000;
}
if (durer1 <= 2)
{
durer1 = 2;
}
/*fin*securite**/
int sens1;
sens1 = 1;
int labase;
int lesommet;
int lesommet1;
int changement;
int varamplitude1a;
varamplitude1a = varamplitude1;
//varamplitude1= 20;
changement = 1;
lesommet = durer1 * 0.5;
if (lesommet>100)
{lesommet = 100;}
lesommet1 = lesommet;

/***Début traitement***/
  FILE *fichierjoa1 = NULL;
  fichierjoa1 = fopen (cecci111, "w");
  if (fichierjoa1 != NULL)
	{/**ouvre fichierle2**/

      while (lesommet > 0)
		{/**ouvreboucl1le3**/

      while (varamplitude1 > 0)
			{/**ouvreboucl1le4**/

switch (sens1)

{

case 1 :
amplitude1 = amplitude1 + changement;
amplitude2 = amplitude2 - changement;

sens1++;

break;
/*****************************/
/*****************************/

case 2 :
sens1++;

break;
/*****************************/
/*****************************/

case 3 :
sens1++;

break;
/*****************************/
/*****************************/

case 4 :
sens1++;

break;
/*****************************/
/*****************************/

case 5 :
sens1++;

break;
/*****************************/
/*****************************/

case 6 :
sens1++;

break;
/*****************************/
/*****************************/

case 7 :
sens1++;

break;
/*****************************/
/*****************************/

case 8 :
sens1++;

break;
/*****************************/
/*****************************/

case 9 :
sens1++;

break;
/*****************************/
/*****************************/
case 10 :
changement++;
sens1 = 1;
break;
/*****************************/
/*****************************/
}



if (amplitude1>230)
{amplitude1 = 230;}
	      fprintf (fichierjoa1, "%d %d\n", amplitude1, nbdepoints1);
amplitude2 = amplitude2 - changement;
if (amplitude2<23)
{amplitude2 = 23;}
	      fprintf (fichierjoa1, "%d %d\n", amplitude2, nbdepoints2);
	      fprintf (fichierjoa1, "%d %d\n", amplitude1, nbdepoints1);
amplitude2 = amplitude2 + changement;
if (amplitude2>230)
{amplitude2 = 230;}
	      fprintf (fichierjoa1, "%d %d\n", amplitude2, nbdepoints2);



	      fprintf (fichierjoa1, "%d %d\n", amplitude1, nbdepoints1);
amplitude2 = amplitude2 - changement;
if (amplitude2<23)
{amplitude2 = 23;}
	      fprintf (fichierjoa1, "%d %d\n", amplitude2, nbdepoints2);
	      fprintf (fichierjoa1, "%d %d\n", amplitude1, nbdepoints1);
amplitude2 = amplitude2 + changement;
if (amplitude2>230)
{amplitude2 = 230;}
	      fprintf (fichierjoa1, "%d %d\n", amplitude2, nbdepoints2);



	      fprintf (fichierjoa1, "%d %d\n", amplitude1, nbdepoints1);
amplitude2 = amplitude2 - changement;
if (amplitude2<23)
{amplitude2 = 23;}
	      fprintf (fichierjoa1, "%d %d\n", amplitude2, nbdepoints2);
	      fprintf (fichierjoa1, "%d %d\n", amplitude1, nbdepoints1);
amplitude2 = amplitude2 + changement;
if (amplitude2>230)
{amplitude2 = 230;}
	      fprintf (fichierjoa1, "%d %d\n", amplitude2, nbdepoints2);







	      	  varamplitude1--;

			}/**fermeboucl1le4**/



	  lesommet--;
		}/**fermeboucl1le3**/



      while (lesommet1 > 0)
		{/**ouvreboucl1le3**/
      while (varamplitude1a > 0)
			{/**ouvreboucl1le4**/

switch (sens1)

{

case 1 :
amplitude1 = amplitude1 - changement;
amplitude2 = amplitude2 + changement;

sens1++;

break;
/*****************************/
/*****************************/
case 2 :
sens1++;

break;
/*****************************/
/*****************************/
case 3 :
sens1++;

break;
/*****************************/
/*****************************/
case 4 :
sens1++;

break;
/*****************************/
/*****************************/
case 5 :
sens1++;

break;
/*****************************/
/*****************************/
case 6 :
sens1++;

break;
/*****************************/
/*****************************/
case 7 :
sens1++;

break;
/*****************************/
/*****************************/
case 8 :
sens1++;

break;
/*****************************/
/*****************************/
case 9 :
sens1++;

break;
/*****************************/
/*****************************/
case 10 :
sens1++;

break;
/*****************************/
/*****************************/
case 11 :
sens1++;

break;
/*****************************/
/*****************************/
case 12 :
sens1++;

break;
/*****************************/
/*****************************/
case 13 :
sens1++;

break;
/*****************************/
/*****************************/
case 14 :
sens1++;

break;
/*****************************/
/*****************************/
case 15 :
sens1++;

break;
/*****************************/
/*****************************/
case 16 :
sens1++;

break;
/*****************************/
/*****************************/
case 17 :
sens1++;

break;
/*****************************/
/*****************************/
case 18 :
sens1++;

break;
/*****************************/
/*****************************/
case 19 :
sens1++;

break;
/*****************************/
/*****************************/
case 20 :
sens1++;

break;
/*****************************/
/*****************************/
case 21 :
sens1++;

break;
/*****************************/
/*****************************/
case 22 :
sens1++;

break;
/*****************************/
/*****************************/
case 23 :
changement--;
sens1 = 1;
break;
/*****************************/
/*****************************/
}



if (amplitude1>230)
{amplitude1 = 230;}
	      fprintf (fichierjoa1, "%d %d\n", amplitude1, nbdepoints1);
amplitude2 = amplitude2 - changement;
if (amplitude2<23)
{amplitude2 = 23;}
	      fprintf (fichierjoa1, "%d %d\n", amplitude2, nbdepoints2);
	      fprintf (fichierjoa1, "%d %d\n", amplitude1, nbdepoints1);
amplitude2 = amplitude2 + changement;
if (amplitude2>230)
{amplitude2 = 230;}
	      fprintf (fichierjoa1, "%d %d\n", amplitude2, nbdepoints2);






	      fprintf (fichierjoa1, "%d %d\n", amplitude1, nbdepoints1);
amplitude2 = amplitude2 - changement;
if (amplitude2<23)
{amplitude2 = 23;}
	      fprintf (fichierjoa1, "%d %d\n", amplitude2, nbdepoints2);
	      fprintf (fichierjoa1, "%d %d\n", amplitude1, nbdepoints1);
amplitude2 = amplitude2 + changement;
if (amplitude2>230)
{amplitude2 = 230;}
	      fprintf (fichierjoa1, "%d %d\n", amplitude2, nbdepoints2);



	      fprintf (fichierjoa1, "%d %d\n", amplitude1, nbdepoints1);
amplitude2 = amplitude2 - changement;
if (amplitude2<23)
{amplitude2 = 23;}
	      fprintf (fichierjoa1, "%d %d\n", amplitude2, nbdepoints2);
	      fprintf (fichierjoa1, "%d %d\n", amplitude1, nbdepoints1);
amplitude2 = amplitude2 + changement;
if (amplitude2>230)
{amplitude2 = 230;}
	      fprintf (fichierjoa1, "%d %d\n", amplitude2, nbdepoints2);


	      	  varamplitude1a--;

		}


	  lesommet1--;
	}

      fclose (fichierjoa1), fichierjoa1 = NULL;;
	}/**ferme fichierle2**/

  vavoir ();
return 0;
}/**ferme le1**/

Ceux qui ont étudié la métallurgie reconnaitrons facilement les paliers et les trempes dans les constructions des formes acoustiques. Il y a une similitude évidentes qui apparait d'une façon encore plus marquée dans la voix humaine.

Dernière modification par temps (Le 12/04/2014, à 07:54)


Parce que l'USB bootable est le support des systèmes experts,
Parce que l'USB bootable contient sa propre image au démarrage.
L'USB bootable permet de créer un monde à la dimension de son imagination

Hors ligne

#7 Le 21/04/2014, à 05:17

temps

Re : lm3jo en deb version 1.1.1-4

Bonjour,
j'ai ajouté à la BAUL un générateur de son "A",
il s'appelle en entrant la lettre "F" dans la ligne des séries appelée.
Comme plusieurs causes peuvent avoir le même effet, la difficulté rencontré n'était de générer des sons "A" c'est très facile, cette simple série en boucle qui fait varier l'avant dernière durée de +1 (la valeur 9), crée un son 'A"

220 32 30 30 220 30 30 34 220 32 30 32 220 32 30 19 32 9 30 10

La difficulté était de choisir une fonction génératrice de son "A" et autres qui soit le plus facile possible à manipuler.
Le son "A" peut être reconstituer à l'aide des 4 formes de base, mais cela demande une connaissance des formes acoustiques. Le but de la création de ces méta-formes est justement de s'affranchir de ces connaissances pour les créateurs acoustiques novices.
On remarquera que par fun, je crée un son "A" à amplitude constante, mais surtout car c'est plus facile à écrire qu'à durée constante ou avec une des nombreuses solutions en vinaigrette.
Voici le code que j'ai arrêté pour l'instant :

int
fonctionpourF (int amplitude1, int amplitude2, int nbdepoints1, int nbdepoints2, int varnbdepoints1, int durer1, int repetition)
{
/*securite**/
if (durer1 > 1000)
{
durer1 = 1000;
}
if (durer1 <= 2)
{
durer1 = 2;
}
if (nbdepoints2 <= 24)
{
nbdepoints2 = 24;
}

/*fin*securite**/

int memoire1;
int memoire2;
int memoire3;
int memoire4;
memoire1 = nbdepoints1;
memoire2 = nbdepoints2;
memoire3 = amplitude2 + 2;
memoire4 = 9;
int passerelledurer;
passerelledurer = durer1;

/***Début traitement***/
  FILE *fichierjoa1 = NULL;
  fichierjoa1 = fopen (cecci111, "w");
  if (fichierjoa1 != NULL)
    {

      while (repetition >= 1)
	{

      while (durer1 > 0)
	{



	      fprintf (fichierjoa1, "%d %d\n", amplitude1, nbdepoints1);
	      fprintf (fichierjoa1, "%d %d\n", amplitude2, nbdepoints2);
nbdepoints1 = nbdepoints1 - 2;
	      fprintf (fichierjoa1, "%d %d\n", amplitude1, nbdepoints1);
nbdepoints2 = nbdepoints2 + 4;
	      fprintf (fichierjoa1, "%d %d\n", amplitude2, nbdepoints2);
nbdepoints1 = nbdepoints1 + 2;
	      fprintf (fichierjoa1, "%d %d\n", amplitude1, nbdepoints1);
nbdepoints2 = nbdepoints2 - 2;
	      fprintf (fichierjoa1, "%d %d\n", amplitude2, nbdepoints2);
	      fprintf (fichierjoa1, "%d %d\n", amplitude1, nbdepoints1);
nbdepoints2 = nbdepoints2 - 13;
	      fprintf (fichierjoa1, "%d %d\n", amplitude2, nbdepoints2);
	      fprintf (fichierjoa1, "%d %d\n", memoire3, memoire4);
nbdepoints2 = nbdepoints2 - 9;
	      fprintf (fichierjoa1, "%d %d\n", amplitude2, nbdepoints2);


nbdepoints1 = memoire1;
nbdepoints2 = memoire2;
memoire4 = memoire4 + varnbdepoints1;

	  durer1--;
	}
	  repetition--;
durer1 = passerelledurer;
	}

      fclose (fichierjoa1), fichierjoa1 = NULL;;
    }

  vavoir ();
return 0;
}

Cordialement

P.S. j'ajoute le lendemain à la relecture. Pour ceux qui veulent avoir le son que représente la lettre "A" plus aigu il ne faut pas penser fréquence, ce concept est faux, il suffit de diminuer légèrement l'amplitude pour réduire la force et ainsi obtenir un son plus aigu.

Dernière modification par temps (Le 22/04/2014, à 01:23)


Parce que l'USB bootable est le support des systèmes experts,
Parce que l'USB bootable contient sa propre image au démarrage.
L'USB bootable permet de créer un monde à la dimension de son imagination

Hors ligne

#8 Le 26/04/2014, à 21:36

temps

Re : lm3jo en deb version 1.1.1-4

Bonjour,
j'ai ajouté à la BAUL un générateur de son "I",
il s'appelle en entrant la lettre "I" dans la ligne des séries appelée.
La particularité du son i se trouve dans les petites crêtes de surface, comme toujours le même son peut être le résultat d'une multitudes d'états d'équilibres, donc peut avoir de nombreuses formes d'écriture, j'ai arrété celle-la pour la BAUL car je pense que c'est la plus simple pour s'amuser à jouer sur les variations du son i

int
fonctionpourI (int amplitude1, int amplitude2, int nbdepoints1,
	       int nbdepoints2, int varnbdepoints1, int durer1,
	       int repetition)
{
/*securite**/
  if (durer1 > 1000)
    {
      durer1 = 1000;
    }
  if (durer1 <= 2)
    {
      durer1 = 2;
    }


/*fin*securite**/

  int memoire1;
  int memoire2;
  int memoire4;
  int memoire5;
  int memoire6;
  int memoire7;
  amplitude1 = 220;
nbdepoints1 = 6;
  memoire5 = 200;
  memoire1 = 3;
  memoire6 = 199;
  memoire2 = 18;



  amplitude2 = 32;
nbdepoints2  = 6;
  memoire7 = 55;
  memoire4 = 57;




  memoire2 = 19;




  int passerelledurer;
  passerelledurer = durer1;

/***Début traitement***/
  FILE *fichierjoa1 = NULL;
  fichierjoa1 = fopen (cecci111, "w");
  if (fichierjoa1 != NULL)
    {

      while (repetition >= 1)
	{

	  while (durer1 > 0)
	    {



	      fprintf (fichierjoa1, "%d %d\n", amplitude1, nbdepoints1);
	      fprintf (fichierjoa1, "%d %d\n", memoire5, memoire1);
	      fprintf (fichierjoa1, "%d %d\n", memoire6, memoire2);
	      fprintf (fichierjoa1, "%d %d\n", amplitude1, memoire1);
	      fprintf (fichierjoa1, "%d %d\n", amplitude2, nbdepoints2);
	      fprintf (fichierjoa1, "%d %d\n", amplitude1, nbdepoints1);

	      fprintf (fichierjoa1, "%d %d\n", amplitude2, nbdepoints2);
	      fprintf (fichierjoa1, "%d %d\n", memoire7, memoire1);
	      fprintf (fichierjoa1, "%d %d\n", memoire4, memoire2);
	      fprintf (fichierjoa1, "%d %d\n", amplitude2, memoire1);


	      durer1--;
	    }
	  repetition--;
	  durer1 = passerelledurer;
	}

      fclose (fichierjoa1), fichierjoa1 = NULL;;
    }

  vavoir ();
  return 0;
}

Ici dans le code les valeurs données sont fixes pour bien montrer la base.
Nous sommes toujours ici dans la logique d'une méta-forme de manière à montrer le chemin, il s'entend que ces sont peuvent être reconstruit à l'aide des 4 formes de bases
Cordialement

Dernière modification par temps (Le 26/04/2014, à 21:38)


Parce que l'USB bootable est le support des systèmes experts,
Parce que l'USB bootable contient sa propre image au démarrage.
L'USB bootable permet de créer un monde à la dimension de son imagination

Hors ligne

Haut de page ↑