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.
nombre réponses : 25

#0 -1 »  lmajo un outil qui génère et lit les notes » Le 28/06/2014, à 07:39

temps
Réponses : 9

Bonjour,
J'annonce la sortie de lmajo à compiler sous qt5

Lmajo reprend une fenêtre du piano virtuel de lm3jo, mais cette fois chaque note du piano virtuel est customisable encore plus facilement car les notes sont construites à l'aide de la technique que j'ai inventé dans le projet BAUL.

C'est en téléchargement ici

Le but est de donner aux tux un outil qui permet de créer son propre instrument de musique.
Je répondrait volontiers aux demandes d'aide de customisation, ne cherchez pas ce lien sur mon site, je l'ai réservé aux forums ou j'ai parfois trouvé de l'aide ou des sources utiles.

Les sources ne pèse que 41 Ko, mais vous pouvez vérifier vous pouvez générer des fichiers audio sans limite de poids, car c'est de la modélisation.

Cordialement

#1 Re : -1 »  lmajo un outil qui génère et lit les notes » Le 29/06/2014, à 01:17

temps
Réponses : 9

Bonjour,
Le paquet est prévue, c'est la raison d'ailleurs de cette version allégée.
Le problème c'est que je dois ajouter deux lib dans qt (sox et gl de qt5), je suis encore entrain de travailler dessus.
Je regarde demain pour donner le apt-get install des deux lib et la ligne de compilation en attendant d'arriver à l'intégrer dans les codes.
Ensuite je passe à la recherche pour créer directement un deb avec qt.
Je pense qu'avant une semaine j'aurai le deb.
Ce qui est intéressant dans cette appli, c'est que chacun peut créer son propre instrument de musique en modifiant l'arrangement dans le fichier avant compil.
Je retouche juste un peu le fichier avant car sous cette version, je génère un fichier audio à chaque appui sur une touche. Afin de ne générer qu'une seule fois au premier appel, je suis entrain de placer des switch pour lancer directement la lecture avec sox en utilisant le fichier audio sans le recréer. Le code sera plus lourd, mais l'application travaillera beaucoup moins.

Voici les dépendances de qt5 pour compiler et jouer

sudo apt-get install libglu1-mesa-dev -y
sudo apt-get install sox

Le marteau acoustique sous sa forme courte produit les différents sons de tambour. Les premières touches données en exemple.
Je viens de changer les touches suivantes pour montrer comment construire des marteaux acoustiques long pour créer les notes de piano. Je ne vais pas laisser longtemps cette forme car je vais ensuite montrer comment créer des marteaux acoustiques pour créer les notes de guitare (faire le tour des trois grandes familles de marteaux acoustiques)
Le piano, c'est tout simplement comme un tambour sur lequel on duplique chaque front de manière à augmenter la force, voir le code pour mieux comprendre. (il n'y a pas de fréquence ou d'algèbre, c'est juste une histoire de forme et de force par le nombre de répétition de chaque front)

Cordialement

#2 Re : -1 »  lmajo un outil qui génère et lit les notes » Le 04/07/2014, à 00:40

temps
Réponses : 9

Bonjour,

Pour ceux qui veulent avoir une dernière information sur la notion de force en acoustique voici un code pour construire un son particulièrement joli avec la lettre y dans lmajo, plus on retire la répétition du front, plus le son nous semble aigu et moins joli, car on abaisse la force.

void
MaFenetre::fonctiontouchey ()
{

      switch (passeley)
	{
	case 1:
	switch (duy)
	{
	case 1:
	varamplitude = 10;
	varnbdepoints = 3;
	durer = 1;
	nbdepointsd = 80;
	actiony ();
	duy = 2;
	 awav[0]='y';
	 awav[1]='1';
	 ajo[0]='y';
void MaFenetre::actiony ()
{


    	int amplituded;
    	int amplitudeh;
    	int amplitudeb;   
	amplitudeh = 220;
	amplitudeb = 30;
	amplituded = 128;



/***Début traitement***/
FILE* fichierjoa1 = NULL;
fichierjoa1 = fopen(cecci111, "w");
if (fichierjoa1 != NULL)
{
fprintf(fichierjoa1, "%d %d\n", amplituded, nbdepointsd);

      while ( durer > 0 )
      {
amplitudeh = amplituded;
amplitudeb = amplituded;
amplitudeh = amplitudeh + varamplitude;
nbdepointsd = nbdepointsd - varnbdepoints;
fprintf(fichierjoa1, "%d %d\n", amplitudeh, nbdepointsd);
amplitudeb = amplitudeb  - varamplitude;
nbdepointsd = nbdepointsd - varnbdepoints;
fprintf(fichierjoa1, "%d %d\n", amplitudeb, nbdepointsd);
fprintf(fichierjoa1, "%d %d\n", amplitudeh, nbdepointsd);
fprintf(fichierjoa1, "%d %d\n", amplitudeb, nbdepointsd);
fprintf(fichierjoa1, "%d %d\n", amplitudeh, nbdepointsd);
fprintf(fichierjoa1, "%d %d\n", amplitudeb, nbdepointsd);
fprintf(fichierjoa1, "%d %d\n", amplitudeh, nbdepointsd);
fprintf(fichierjoa1, "%d %d\n", amplitudeb, nbdepointsd);
fprintf(fichierjoa1, "%d %d\n", amplitudeh, nbdepointsd);
fprintf(fichierjoa1, "%d %d\n", amplitudeb, nbdepointsd);
fprintf(fichierjoa1, "%d %d\n", amplitudeh, nbdepointsd);
fprintf(fichierjoa1, "%d %d\n", amplitudeb, nbdepointsd);
fprintf(fichierjoa1, "%d %d\n", amplitudeh, nbdepointsd);
fprintf(fichierjoa1, "%d %d\n", amplitudeb, nbdepointsd);
fprintf(fichierjoa1, "%d %d\n", amplitudeh, nbdepointsd);
fprintf(fichierjoa1, "%d %d\n", amplitudeb, nbdepointsd);
fprintf(fichierjoa1, "%d %d\n", amplitudeh, nbdepointsd);
fprintf(fichierjoa1, "%d %d\n", amplitudeb, nbdepointsd);
amplitudeh = amplitudeh + varamplitude;
nbdepointsd = nbdepointsd - varnbdepoints;
fprintf(fichierjoa1, "%d %d\n", amplitudeh, nbdepointsd);
amplitudeb = amplitudeb  - varamplitude;
nbdepointsd = nbdepointsd - varnbdepoints;
fprintf(fichierjoa1, "%d %d\n", amplitudeb, nbdepointsd);
fprintf(fichierjoa1, "%d %d\n", amplitudeh, nbdepointsd);
fprintf(fichierjoa1, "%d %d\n", amplitudeb, nbdepointsd);
fprintf(fichierjoa1, "%d %d\n", amplitudeh, nbdepointsd);
fprintf(fichierjoa1, "%d %d\n", amplitudeb, nbdepointsd);
fprintf(fichierjoa1, "%d %d\n", amplitudeh, nbdepointsd);
fprintf(fichierjoa1, "%d %d\n", amplitudeb, nbdepointsd);
fprintf(fichierjoa1, "%d %d\n", amplitudeh, nbdepointsd);
fprintf(fichierjoa1, "%d %d\n", amplitudeb, nbdepointsd);
fprintf(fichierjoa1, "%d %d\n", amplitudeh, nbdepointsd);
fprintf(fichierjoa1, "%d %d\n", amplitudeb, nbdepointsd);
fprintf(fichierjoa1, "%d %d\n", amplitudeh, nbdepointsd);
fprintf(fichierjoa1, "%d %d\n", amplitudeb, nbdepointsd);
fprintf(fichierjoa1, "%d %d\n", amplitudeh, nbdepointsd);
fprintf(fichierjoa1, "%d %d\n", amplitudeb, nbdepointsd);
fprintf(fichierjoa1, "%d %d\n", amplitudeh, nbdepointsd);
fprintf(fichierjoa1, "%d %d\n", amplitudeb, nbdepointsd);
amplitudeh = amplitudeh + varamplitude;
nbdepointsd = nbdepointsd - varnbdepoints;
fprintf(fichierjoa1, "%d %d\n", amplitudeh, nbdepointsd);
amplitudeb = amplitudeb  - varamplitude;
nbdepointsd = nbdepointsd - varnbdepoints;
fprintf(fichierjoa1, "%d %d\n", amplitudeb, nbdepointsd);
fprintf(fichierjoa1, "%d %d\n", amplitudeh, nbdepointsd);
fprintf(fichierjoa1, "%d %d\n", amplitudeb, nbdepointsd);
fprintf(fichierjoa1, "%d %d\n", amplitudeh, nbdepointsd);
fprintf(fichierjoa1, "%d %d\n", amplitudeb, nbdepointsd);
fprintf(fichierjoa1, "%d %d\n", amplitudeh, nbdepointsd);
fprintf(fichierjoa1, "%d %d\n", amplitudeb, nbdepointsd);
fprintf(fichierjoa1, "%d %d\n", amplitudeh, nbdepointsd);
fprintf(fichierjoa1, "%d %d\n", amplitudeb, nbdepointsd);
fprintf(fichierjoa1, "%d %d\n", amplitudeh, nbdepointsd);
fprintf(fichierjoa1, "%d %d\n", amplitudeb, nbdepointsd);
fprintf(fichierjoa1, "%d %d\n", amplitudeh, nbdepointsd);
fprintf(fichierjoa1, "%d %d\n", amplitudeb, nbdepointsd);
fprintf(fichierjoa1, "%d %d\n", amplitudeh, nbdepointsd);
fprintf(fichierjoa1, "%d %d\n", amplitudeb, nbdepointsd);
fprintf(fichierjoa1, "%d %d\n", amplitudeh, nbdepointsd);
fprintf(fichierjoa1, "%d %d\n", amplitudeb, nbdepointsd);
amplitudeh = amplitudeh + varamplitude;
nbdepointsd = nbdepointsd - varnbdepoints;
fprintf(fichierjoa1, "%d %d\n", amplitudeh, nbdepointsd);
amplitudeb = amplitudeb  - varamplitude;
nbdepointsd = nbdepointsd - varnbdepoints;
fprintf(fichierjoa1, "%d %d\n", amplitudeb, nbdepointsd);
fprintf(fichierjoa1, "%d %d\n", amplitudeh, nbdepointsd);
fprintf(fichierjoa1, "%d %d\n", amplitudeb, nbdepointsd);
fprintf(fichierjoa1, "%d %d\n", amplitudeh, nbdepointsd);
fprintf(fichierjoa1, "%d %d\n", amplitudeb, nbdepointsd);
fprintf(fichierjoa1, "%d %d\n", amplitudeh, nbdepointsd);
fprintf(fichierjoa1, "%d %d\n", amplitudeb, nbdepointsd);
fprintf(fichierjoa1, "%d %d\n", amplitudeh, nbdepointsd);
fprintf(fichierjoa1, "%d %d\n", amplitudeb, nbdepointsd);
fprintf(fichierjoa1, "%d %d\n", amplitudeh, nbdepointsd);
fprintf(fichierjoa1, "%d %d\n", amplitudeb, nbdepointsd);
fprintf(fichierjoa1, "%d %d\n", amplitudeh, nbdepointsd);
fprintf(fichierjoa1, "%d %d\n", amplitudeb, nbdepointsd);
fprintf(fichierjoa1, "%d %d\n", amplitudeh, nbdepointsd);
fprintf(fichierjoa1, "%d %d\n", amplitudeb, nbdepointsd);
fprintf(fichierjoa1, "%d %d\n", amplitudeh, nbdepointsd);
fprintf(fichierjoa1, "%d %d\n", amplitudeb, nbdepointsd);
amplitudeh = amplitudeh + varamplitude;
nbdepointsd = nbdepointsd - varnbdepoints;
fprintf(fichierjoa1, "%d %d\n", amplitudeh, nbdepointsd);
amplitudeb = amplitudeb  - varamplitude;
nbdepointsd = nbdepointsd - varnbdepoints;
fprintf(fichierjoa1, "%d %d\n", amplitudeb, nbdepointsd);
fprintf(fichierjoa1, "%d %d\n", amplitudeh, nbdepointsd);
fprintf(fichierjoa1, "%d %d\n", amplitudeb, nbdepointsd);
fprintf(fichierjoa1, "%d %d\n", amplitudeh, nbdepointsd);
fprintf(fichierjoa1, "%d %d\n", amplitudeb, nbdepointsd);
fprintf(fichierjoa1, "%d %d\n", amplitudeh, nbdepointsd);
fprintf(fichierjoa1, "%d %d\n", amplitudeb, nbdepointsd);
fprintf(fichierjoa1, "%d %d\n", amplitudeh, nbdepointsd);
fprintf(fichierjoa1, "%d %d\n", amplitudeb, nbdepointsd);
fprintf(fichierjoa1, "%d %d\n", amplitudeh, nbdepointsd);
fprintf(fichierjoa1, "%d %d\n", amplitudeb, nbdepointsd);
fprintf(fichierjoa1, "%d %d\n", amplitudeh, nbdepointsd);
fprintf(fichierjoa1, "%d %d\n", amplitudeb, nbdepointsd);
fprintf(fichierjoa1, "%d %d\n", amplitudeh, nbdepointsd);
fprintf(fichierjoa1, "%d %d\n", amplitudeb, nbdepointsd);
fprintf(fichierjoa1, "%d %d\n", amplitudeh, nbdepointsd);
fprintf(fichierjoa1, "%d %d\n", amplitudeb, nbdepointsd);
amplitudeh = amplitudeh + varamplitude;
nbdepointsd = nbdepointsd - varnbdepoints;
fprintf(fichierjoa1, "%d %d\n", amplitudeh, nbdepointsd);
amplitudeb = amplitudeb  - varamplitude;
nbdepointsd = nbdepointsd - varnbdepoints;
fprintf(fichierjoa1, "%d %d\n", amplitudeb, nbdepointsd);
fprintf(fichierjoa1, "%d %d\n", amplitudeh, nbdepointsd);
fprintf(fichierjoa1, "%d %d\n", amplitudeb, nbdepointsd);
fprintf(fichierjoa1, "%d %d\n", amplitudeh, nbdepointsd);
fprintf(fichierjoa1, "%d %d\n", amplitudeb, nbdepointsd);
fprintf(fichierjoa1, "%d %d\n", amplitudeh, nbdepointsd);
fprintf(fichierjoa1, "%d %d\n", amplitudeb, nbdepointsd);
fprintf(fichierjoa1, "%d %d\n", amplitudeh, nbdepointsd);
fprintf(fichierjoa1, "%d %d\n", amplitudeb, nbdepointsd);
fprintf(fichierjoa1, "%d %d\n", amplitudeh, nbdepointsd);
fprintf(fichierjoa1, "%d %d\n", amplitudeb, nbdepointsd);
fprintf(fichierjoa1, "%d %d\n", amplitudeh, nbdepointsd);
fprintf(fichierjoa1, "%d %d\n", amplitudeb, nbdepointsd);
fprintf(fichierjoa1, "%d %d\n", amplitudeh, nbdepointsd);
fprintf(fichierjoa1, "%d %d\n", amplitudeb, nbdepointsd);
fprintf(fichierjoa1, "%d %d\n", amplitudeh, nbdepointsd);
fprintf(fichierjoa1, "%d %d\n", amplitudeb, nbdepointsd);
amplitudeh = amplitudeh + varamplitude;
nbdepointsd = nbdepointsd - varnbdepoints;
fprintf(fichierjoa1, "%d %d\n", amplitudeh, nbdepointsd);
amplitudeb = amplitudeb  - varamplitude;
nbdepointsd = nbdepointsd - varnbdepoints;
fprintf(fichierjoa1, "%d %d\n", amplitudeb, nbdepointsd);
fprintf(fichierjoa1, "%d %d\n", amplitudeh, nbdepointsd);
fprintf(fichierjoa1, "%d %d\n", amplitudeb, nbdepointsd);
fprintf(fichierjoa1, "%d %d\n", amplitudeh, nbdepointsd);
fprintf(fichierjoa1, "%d %d\n", amplitudeb, nbdepointsd);
fprintf(fichierjoa1, "%d %d\n", amplitudeh, nbdepointsd);
fprintf(fichierjoa1, "%d %d\n", amplitudeb, nbdepointsd);
fprintf(fichierjoa1, "%d %d\n", amplitudeh, nbdepointsd);
fprintf(fichierjoa1, "%d %d\n", amplitudeb, nbdepointsd);
fprintf(fichierjoa1, "%d %d\n", amplitudeh, nbdepointsd);
fprintf(fichierjoa1, "%d %d\n", amplitudeb, nbdepointsd);
fprintf(fichierjoa1, "%d %d\n", amplitudeh, nbdepointsd);
fprintf(fichierjoa1, "%d %d\n", amplitudeb, nbdepointsd);
fprintf(fichierjoa1, "%d %d\n", amplitudeh, nbdepointsd);
fprintf(fichierjoa1, "%d %d\n", amplitudeb, nbdepointsd);
fprintf(fichierjoa1, "%d %d\n", amplitudeh, nbdepointsd);
fprintf(fichierjoa1, "%d %d\n", amplitudeb, nbdepointsd);
amplitudeh = amplitudeh + varamplitude;
nbdepointsd = nbdepointsd - varnbdepoints;
fprintf(fichierjoa1, "%d %d\n", amplitudeh, nbdepointsd);
amplitudeb = amplitudeb  - varamplitude;
nbdepointsd = nbdepointsd - varnbdepoints;
fprintf(fichierjoa1, "%d %d\n", amplitudeb, nbdepointsd);
fprintf(fichierjoa1, "%d %d\n", amplitudeh, nbdepointsd);
fprintf(fichierjoa1, "%d %d\n", amplitudeb, nbdepointsd);
fprintf(fichierjoa1, "%d %d\n", amplitudeh, nbdepointsd);
fprintf(fichierjoa1, "%d %d\n", amplitudeb, nbdepointsd);
fprintf(fichierjoa1, "%d %d\n", amplitudeh, nbdepointsd);
fprintf(fichierjoa1, "%d %d\n", amplitudeb, nbdepointsd);
fprintf(fichierjoa1, "%d %d\n", amplitudeh, nbdepointsd);
fprintf(fichierjoa1, "%d %d\n", amplitudeb, nbdepointsd);
fprintf(fichierjoa1, "%d %d\n", amplitudeh, nbdepointsd);
fprintf(fichierjoa1, "%d %d\n", amplitudeb, nbdepointsd);
fprintf(fichierjoa1, "%d %d\n", amplitudeh, nbdepointsd);
fprintf(fichierjoa1, "%d %d\n", amplitudeb, nbdepointsd);
fprintf(fichierjoa1, "%d %d\n", amplitudeh, nbdepointsd);
fprintf(fichierjoa1, "%d %d\n", amplitudeb, nbdepointsd);
fprintf(fichierjoa1, "%d %d\n", amplitudeh, nbdepointsd);
fprintf(fichierjoa1, "%d %d\n", amplitudeb, nbdepointsd);
amplitudeh = amplitudeh + varamplitude;
nbdepointsd = nbdepointsd - varnbdepoints;
fprintf(fichierjoa1, "%d %d\n", amplitudeh, nbdepointsd);
amplitudeb = amplitudeb  - varamplitude;
nbdepointsd = nbdepointsd - varnbdepoints;
fprintf(fichierjoa1, "%d %d\n", amplitudeb, nbdepointsd);
fprintf(fichierjoa1, "%d %d\n", amplitudeh, nbdepointsd);
fprintf(fichierjoa1, "%d %d\n", amplitudeb, nbdepointsd);
fprintf(fichierjoa1, "%d %d\n", amplitudeh, nbdepointsd);
fprintf(fichierjoa1, "%d %d\n", amplitudeb, nbdepointsd);
fprintf(fichierjoa1, "%d %d\n", amplitudeh, nbdepointsd);
fprintf(fichierjoa1, "%d %d\n", amplitudeb, nbdepointsd);
fprintf(fichierjoa1, "%d %d\n", amplitudeh, nbdepointsd);
fprintf(fichierjoa1, "%d %d\n", amplitudeb, nbdepointsd);
fprintf(fichierjoa1, "%d %d\n", amplitudeh, nbdepointsd);
fprintf(fichierjoa1, "%d %d\n", amplitudeb, nbdepointsd);
fprintf(fichierjoa1, "%d %d\n", amplitudeh, nbdepointsd);
fprintf(fichierjoa1, "%d %d\n", amplitudeb, nbdepointsd);
fprintf(fichierjoa1, "%d %d\n", amplitudeh, nbdepointsd);
fprintf(fichierjoa1, "%d %d\n", amplitudeb, nbdepointsd);
fprintf(fichierjoa1, "%d %d\n", amplitudeh, nbdepointsd);
fprintf(fichierjoa1, "%d %d\n", amplitudeb, nbdepointsd);
amplitudeh = amplitudeh + varamplitude;
nbdepointsd = nbdepointsd - varnbdepoints;
fprintf(fichierjoa1, "%d %d\n", amplitudeh, nbdepointsd);
amplitudeb = amplitudeb  - varamplitude;
nbdepointsd = nbdepointsd - varnbdepoints;
fprintf(fichierjoa1, "%d %d\n", amplitudeb, nbdepointsd);
fprintf(fichierjoa1, "%d %d\n", amplitudeh, nbdepointsd);
fprintf(fichierjoa1, "%d %d\n", amplitudeb, nbdepointsd);
fprintf(fichierjoa1, "%d %d\n", amplitudeh, nbdepointsd);
fprintf(fichierjoa1, "%d %d\n", amplitudeb, nbdepointsd);
fprintf(fichierjoa1, "%d %d\n", amplitudeh, nbdepointsd);
fprintf(fichierjoa1, "%d %d\n", amplitudeb, nbdepointsd);
fprintf(fichierjoa1, "%d %d\n", amplitudeh, nbdepointsd);
fprintf(fichierjoa1, "%d %d\n", amplitudeb, nbdepointsd);
fprintf(fichierjoa1, "%d %d\n", amplitudeh, nbdepointsd);
fprintf(fichierjoa1, "%d %d\n", amplitudeb, nbdepointsd);
fprintf(fichierjoa1, "%d %d\n", amplitudeh, nbdepointsd);
fprintf(fichierjoa1, "%d %d\n", amplitudeb, nbdepointsd);
fprintf(fichierjoa1, "%d %d\n", amplitudeh, nbdepointsd);
fprintf(fichierjoa1, "%d %d\n", amplitudeb, nbdepointsd);
fprintf(fichierjoa1, "%d %d\n", amplitudeh, nbdepointsd);
fprintf(fichierjoa1, "%d %d\n", amplitudeb, nbdepointsd);





amplitudeh = amplitudeh - varamplitude;
nbdepointsd = nbdepointsd + varnbdepoints;
fprintf(fichierjoa1, "%d %d\n", amplitudeh, nbdepointsd);
amplitudeb = amplitudeb  + varamplitude;
nbdepointsd = nbdepointsd + varnbdepoints;
fprintf(fichierjoa1, "%d %d\n", amplitudeb, nbdepointsd);
fprintf(fichierjoa1, "%d %d\n", amplitudeh, nbdepointsd);
fprintf(fichierjoa1, "%d %d\n", amplitudeb, nbdepointsd);
fprintf(fichierjoa1, "%d %d\n", amplitudeh, nbdepointsd);
fprintf(fichierjoa1, "%d %d\n", amplitudeb, nbdepointsd);
amplitudeh = amplitudeh - varamplitude;
nbdepointsd = nbdepointsd + varnbdepoints;
fprintf(fichierjoa1, "%d %d\n", amplitudeh, nbdepointsd);
amplitudeb = amplitudeb  + varamplitude;
nbdepointsd = nbdepointsd + varnbdepoints;
fprintf(fichierjoa1, "%d %d\n", amplitudeb, nbdepointsd);
fprintf(fichierjoa1, "%d %d\n", amplitudeh, nbdepointsd);
fprintf(fichierjoa1, "%d %d\n", amplitudeb, nbdepointsd);
fprintf(fichierjoa1, "%d %d\n", amplitudeh, nbdepointsd);
fprintf(fichierjoa1, "%d %d\n", amplitudeb, nbdepointsd);
amplitudeh = amplitudeh - varamplitude;
nbdepointsd = nbdepointsd + varnbdepoints;
fprintf(fichierjoa1, "%d %d\n", amplitudeh, nbdepointsd);
amplitudeb = amplitudeb  + varamplitude;
nbdepointsd = nbdepointsd + varnbdepoints;
fprintf(fichierjoa1, "%d %d\n", amplitudeb, nbdepointsd);
fprintf(fichierjoa1, "%d %d\n", amplitudeh, nbdepointsd);
fprintf(fichierjoa1, "%d %d\n", amplitudeb, nbdepointsd);
fprintf(fichierjoa1, "%d %d\n", amplitudeh, nbdepointsd);
fprintf(fichierjoa1, "%d %d\n", amplitudeb, nbdepointsd);
amplitudeh = amplitudeh - varamplitude;
nbdepointsd = nbdepointsd + varnbdepoints;
fprintf(fichierjoa1, "%d %d\n", amplitudeh, nbdepointsd);
amplitudeb = amplitudeb  + varamplitude;
nbdepointsd = nbdepointsd + varnbdepoints;
fprintf(fichierjoa1, "%d %d\n", amplitudeb, nbdepointsd);
fprintf(fichierjoa1, "%d %d\n", amplitudeh, nbdepointsd);
fprintf(fichierjoa1, "%d %d\n", amplitudeb, nbdepointsd);
fprintf(fichierjoa1, "%d %d\n", amplitudeh, nbdepointsd);
fprintf(fichierjoa1, "%d %d\n", amplitudeb, nbdepointsd);
amplitudeh = amplitudeh - varamplitude;
nbdepointsd = nbdepointsd + varnbdepoints;
fprintf(fichierjoa1, "%d %d\n", amplitudeh, nbdepointsd);
amplitudeb = amplitudeb  + varamplitude;
nbdepointsd = nbdepointsd + varnbdepoints;
fprintf(fichierjoa1, "%d %d\n", amplitudeb, nbdepointsd);
fprintf(fichierjoa1, "%d %d\n", amplitudeh, nbdepointsd);
fprintf(fichierjoa1, "%d %d\n", amplitudeb, nbdepointsd);
fprintf(fichierjoa1, "%d %d\n", amplitudeh, nbdepointsd);
fprintf(fichierjoa1, "%d %d\n", amplitudeb, nbdepointsd);
amplitudeh = amplitudeh - varamplitude;
nbdepointsd = nbdepointsd + varnbdepoints;
fprintf(fichierjoa1, "%d %d\n", amplitudeh, nbdepointsd);
amplitudeb = amplitudeb  + varamplitude;
nbdepointsd = nbdepointsd + varnbdepoints;
fprintf(fichierjoa1, "%d %d\n", amplitudeb, nbdepointsd);
fprintf(fichierjoa1, "%d %d\n", amplitudeh, nbdepointsd);
fprintf(fichierjoa1, "%d %d\n", amplitudeb, nbdepointsd);
fprintf(fichierjoa1, "%d %d\n", amplitudeh, nbdepointsd);
fprintf(fichierjoa1, "%d %d\n", amplitudeb, nbdepointsd);
amplitudeh = amplitudeh - varamplitude;
nbdepointsd = nbdepointsd + varnbdepoints;
fprintf(fichierjoa1, "%d %d\n", amplitudeh, nbdepointsd);
amplitudeb = amplitudeb  + varamplitude;
nbdepointsd = nbdepointsd + varnbdepoints;
fprintf(fichierjoa1, "%d %d\n", amplitudeb, nbdepointsd);
fprintf(fichierjoa1, "%d %d\n", amplitudeh, nbdepointsd);
fprintf(fichierjoa1, "%d %d\n", amplitudeb, nbdepointsd);
fprintf(fichierjoa1, "%d %d\n", amplitudeh, nbdepointsd);
fprintf(fichierjoa1, "%d %d\n", amplitudeb, nbdepointsd);
amplitudeh = amplitudeh - varamplitude;
nbdepointsd = nbdepointsd + varnbdepoints;
fprintf(fichierjoa1, "%d %d\n", amplitudeh, nbdepointsd);
amplitudeb = amplitudeb  + varamplitude;
nbdepointsd = nbdepointsd + varnbdepoints;
fprintf(fichierjoa1, "%d %d\n", amplitudeb, nbdepointsd);
fprintf(fichierjoa1, "%d %d\n", amplitudeh, nbdepointsd);
fprintf(fichierjoa1, "%d %d\n", amplitudeb, nbdepointsd);
fprintf(fichierjoa1, "%d %d\n", amplitudeh, nbdepointsd);
fprintf(fichierjoa1, "%d %d\n", amplitudeb, nbdepointsd);
amplitudeh = amplitudeh - varamplitude;
nbdepointsd = nbdepointsd + varnbdepoints;
fprintf(fichierjoa1, "%d %d\n", amplitudeh, nbdepointsd);
amplitudeb = amplitudeb  + varamplitude;
nbdepointsd = nbdepointsd + varnbdepoints;
fprintf(fichierjoa1, "%d %d\n", amplitudeb, nbdepointsd);
fprintf(fichierjoa1, "%d %d\n", amplitudeh, nbdepointsd);
fprintf(fichierjoa1, "%d %d\n", amplitudeb, nbdepointsd);
fprintf(fichierjoa1, "%d %d\n", amplitudeh, nbdepointsd);
fprintf(fichierjoa1, "%d %d\n", amplitudeb, nbdepointsd);
amplitudeh = amplitudeh - varamplitude;
nbdepointsd = nbdepointsd + varnbdepoints;
fprintf(fichierjoa1, "%d %d\n", amplitudeh, nbdepointsd);
amplitudeb = amplitudeb  + varamplitude;
nbdepointsd = nbdepointsd + varnbdepoints;
fprintf(fichierjoa1, "%d %d\n", amplitudeb, nbdepointsd);
fprintf(fichierjoa1, "%d %d\n", amplitudeh, nbdepointsd);
fprintf(fichierjoa1, "%d %d\n", amplitudeb, nbdepointsd);
fprintf(fichierjoa1, "%d %d\n", amplitudeh, nbdepointsd);
fprintf(fichierjoa1, "%d %d\n", amplitudeb, nbdepointsd);



durer--;
 }

fclose(fichierjoa1), fichierjoa1 = NULL;;
}
vavoiry();


  }


J'abandonne l'idée de montrer comment fonctionne l'acoustique. Puisque wikipedia rejette mes démonstrations, que les RMLL rejette mes conférences pour montrer mon format audio et ses lois de fonctionnement, ou la BAUL, que visiblement ça sert à rien que je partage mes codes sous linux.
Je pense sincèrement que pour pouvoir se prétendre comme faisant partie du libre, la première chose à faire, c'est de ne pas abrutir les gens, en leur présentant des concepts faux. Depuis 4 ans, je montre et démontre les lois de l'acoustique, j'ai compris, maintenant je ne donnerai plus que des outils tout fait sans jamais plus donner une explication.

Cordialement

#3 Re : -1 »  lmajo un outil qui génère et lit les notes » Le 04/07/2014, à 20:23

temps
Réponses : 9

Bonjour,
"susceptible" je pense sincèrement que non, preuve en est, c'est que demain matin je serai aux RMLL alors même que je ne peux diffuser une info importante par conférence.
Ce n'est pas parce-qu'il y a un vers dans la pomme que je jette la pomme.
Mon intention est de procéder différemment. 
Acte un ; créer des petites applications ludiques. Si un tux (ou FreeBSD) me demande les codes et comment compiler, je continue à partager le savoir, et donne en aparté un lien de téléchargement.
Acte deux, je vais créer une société et vendre sur les systèmes propriétaires. Si ça marche, je pourrai créer mes propres composant et sponsoriser ceux qui font vraiment du libre à mon sentiment.

Je viens de créer un nouveau piano virtuel en utilisant les licornes, l’avantage d'utiliser les licornes, c'est que cela me permet de montrer simplement l'effet des forces en acoustique, une notion physique pas encore reconnue et à par quelques amis pas comprise.
c'est ici http://commons.wikimedia.org/w/index.ph … =128144731  ou ici
http://commons.wikimedia.org/w/index.ph … =128144727
Si le marteau acoustique permet de créer les tambours, les guitare, les piano , la licorne permet de créer les sons autour de la voix humaine.

Pour compiler, il suffit de gratter mes lien, c'est donné dans lm3jo comment compiler, je suis trop pris à créer pour avoir eu le temps d'effacer tous les codes. Ce week-end je suis pris aux RMLL, mais après je regarderai d'enlever les codes pour les donner qu'à ceux qui sont curieux et ouvert. En d'autres mots, J'ai réalisé que c'est une erreur de contrarier ceux qui mélange sciences et croyances, et que les fous de Dieu sont très dangereux.

Cordialement

#4 Re : -1 »  lmajo un outil qui génère et lit les notes » Le 10/07/2014, à 17:17

temps
Réponses : 9

Bonjour,
J'ai ajouté lmcjo qui produit des sons de basse électrique. Le principe d'une guitare basse est de créer une forme de marteau acoustique à durée constante, ensuite de renforcer la force. Dans l'instrument musical lmcjo, je part de 240 et diminue de 7 par note, pour obtenir un son plus aigue, il faut remplacer la valeur dans nbpoints ici

	varamplitude = 1;
	varnbdepoints = 0;
	durer = 94;
	nbdepointsd = 240;
	action ();

pour la note b, faire une recherche de terme actionb suffit.
pour la note c, faire une recherche de terme actionc ....
Pour augmenter la force il suffit d'augmenter la répétition en exemple en créant une boucle, comme je l'ai fait sur les licornes dans lmbjo.

Pour compiler c'est qmake, ou on peut utiliser qtcreator, ça marche aussi en ouvrant le fichier .pro

pour entendre c'est ici
pour vois c'est ici

Cordialement

#5 Re : -1 »  lmajo un outil qui génère et lit les notes » Le 12/07/2014, à 08:06

temps
Réponses : 9

Bonjour,

J'ai ajouté la version orgue qui se nomme lmdjo, pour entendre les notes, c'est ici

Je recherche un musicien qui arrive à identifier les notes, de manière à donner un repère aux tux utilisateurs débutant en musique qui veulent tester en utilisant des partitions.
Comme je construits plusieurs notes différentes en utilisant que les forces et les amplitudes sans changer la valeur de ce qui se nomme fréquence, et que je n'ai pas l'oreille acoustique, je suis incapable de le faire tout seul.

J'ai ajouté le piano virtuel lmfjo qui montre les effets de plateau et de variation de force à écouter ici :
https://commons.wikimedia.org/wiki/File:Lmfjo.ogg

Un petit ajout suite à une conversation que j'ai eu hier soir avec un tux. La difficulté rencontré pour identifier les notes provient de ma technique de modélisation. Je parle en durée, il faut 44100 points de durée pour faire une seconde.
Prenons le cas d'un des premiers sons de voix humaine que j'ai créé, un son "A" que je pense avoir mis sur wikimedia. J'ai construit ce son "A" avec 4 fronts de durée répétés en boucle:
premiers fronts 15 points, deuxième front 9 points, troisième front de 9 points, quatrième front de 12 points.
En prenant les notions de fréquence, cela doit donner à la louche dans les vingt mille Hz, et pourtant j'obtiens un joli son "A"
La technique est que je donne pas de force aux fronts pour ne donner de la force qu'à la partie qui fait apparaître le son "A"
Si vous regardez les infos construites sur un concept de fréquence, données sur la toile, vous vous apercevez que la toile déclare que c'est impossible. Alors que mon son "A" existe bien

Cordialement

#6 Re : -1 »  lmajo un outil qui génère et lit les notes » Le 16/07/2014, à 01:38

temps
Réponses : 9

Bonjour,
je viens de finir lmhjo, je vais l'ajouter bientot, et c'est ici 
La particularité c'est que je crée une forme sonore que je fais surfer. Nous retrouvons ici l'utilisation de la licorne, des forces, de l'effet mémoire et même la vinaigrette sur une note. Ce piano n'est pas très utile sous cette forme, mais est facilement modifiable pour créer la voix humaine, en exemple la note "k" en echo avec un étirement produit un joli 'A"
Toutes ces notes sont construites  avec seulement 6 fronts en boucle, donc sont très légères à écrire

En exemple pour avoir un son étiré sur la note "A", il faut faire une recherche dans le fichier MaFenêtre.cpp avec le terme

action 

,
ensuite remplacé

	durer = 1;
	laforceh = 7;
	laforceb = 14;
	action ();

par

	durer = 1;
	laforceh = 14;
	laforceb = 14;
	action ();

pour augmenter le nombre de répétition de la boucle, (le chiffre 7 je l'ai donné en hommage à la Calas qui est la reine du surf vocale avec une forme de base à seulement 7).
comme dans la boucle nous faisons une variation d'amplitude des 6 fronts, il faut aussi modifier la variation d'amplitude pour ne pas avoir de saturation et remplacer les variation de 13 par des variations de 7,
ce qui donne :

	 amplitude1 = amplitude1 + 7;
	 amplitude2 = amplitude2 - 8;
	 amplitude3 = amplitude3 + 7;
	 amplitude4 = amplitude4 - 7;
	 amplitude5 = amplitude5 + 8;
	 amplitude6 = amplitude6 - 7;

Je ne mets pas ce son en ligne, il est réservé à ceux qui crée leur propre instrument de musique et le customise en compilant l'application sous qt. Ici un son "A" langoureux de 161 ko en wav produit avec 6 fronts

Une video d'exemple de 6 fronts sans variation de durée se trouve ici

J'ai ajouté une série de piano virtuel de durées constantes à cette adresse ;
http://www.letime.net/vocale/lmmodel1jo.tar.gz
et une vidéo d'un des piano type violon ici


Cordialement

#7 Re : -1 »  lmajo un outil qui génère et lit les notes » Le 21/07/2014, à 05:08

temps
Réponses : 9

Bonjour,
Je viens d'ajouter un tutoriel qui montre comment ne pas dépasser les portes d'un son car plus nous descendons en durée moins le son a de force, pour rattraper il suffit de répéter le front pour augmenter sa force, mais une petite vidéo de présentation de lmmodel10jo. Lmmodel10jo est un piano virtuel issu de la Bibliothèque Acoustique Universelle.
Ce tutorielle montre comment jouer sur la vitesse de descente du marteau acoustique, afin que la variation de la force ne dépasse pas la porte (limite que peut atteindre une force dans un son avant de le déformer).

La vidéo montre aussi comment ouvrir le fichier .pro et compiler avec qtcreator

j'ai ajouté deux piano synthétisant des notes d'orgue octave 0 à octave 3 sans rattraper les longueurs des notes en jouant sur les variations d'amplitude, c'est ici ou en compilant lmmodel14jo et lmmodel15jo

Piano virtuel lmmodel23jo, est issu de la BAUL et chaque note s'écrit avec 16 octets. Les 26 notes présentées sont octave qui vous plaira, sous une licorne de 4 fronts. Ce piano virtuel est éducatif et me permets de montrer comment construire un son de violon, violoncelle ...
Le principe est de prendre un front de le faire suivre d'un front court, de reprendre ce front et enfin de le faire suivre d'un front long. Nous jouons avec deux états d'équilibre et hop voici le violon.
c'est ici



Cordialement

#8 Re : -1 »  Capture son impossible avec RecordMyDesktop [Résolu] » Le 14/07/2014, à 17:12

temps
Réponses : 13

Bonjour,
Je teste régulièrement cette application et la meilleure solution est de passer par le "hard", un simple cable à un peu plus de 1 euro, un male/male jack 3.5 entre la sortie audio et l'entrée du micro. Autrement par le soft, la solution qui fonctionne le plus souvent est en passant par Table de mixage sonore ALSA pour GNOME, mais mais ça dépend de la config

Cordialement

#9 Re : -1 »  Capture son impossible avec RecordMyDesktop [Résolu] » Le 15/07/2014, à 15:28

temps
Réponses : 13

Bonjour,
la voie écologique c'est le cable en cuivre, il ne consomme pas d'énergie. jack 3.5 male/male
Le mixer se trouve en faisant une simple recherche avec le terme mixer dans la bibliothèque d'application.

Cordialement

#10 Re : -1 »  Capture son impossible avec RecordMyDesktop [Résolu] » Le 16/07/2014, à 17:04

temps
Réponses : 13

Donc si j'ai bien compris le problème n'est pas résolu ?
C'est normal de vouloir comprendre, il y a des tuto sur le site

Peut-être est-ce un problème de carte
voir http://doc.ubuntu-fr.org/audio_intel_hda

http://doc.ubuntu-fr.org/son
et
http://doc.ubuntu-fr.org/son_problemes
http://doc.ubuntu-fr.org/son_cartes_son
http://doc.ubuntu-fr.org/connaitre_son_materiel

puis
http://ubuntuforums.org/showthread.php?t=856390


Pour le reste il y a beaucoup d'imagination. De fait nos poubelles sont pleines de jack 3.5, un pour le casque et un pour le micro. J'en ai 9 rien que sur mon bureau. Avec une paire de ciseau et du ruban adhésif, il ne faut pas longtemps pour se créer son cordon male/male 3.5.

La démarche pour résoudre serait selon moi, en premier d'identifier la carte son. Vérifier qu'il y a le bon pilote. Ensuite d'installer le bon mixer après avoir nettoyer toutes les tentatives précédentes. Donc que donne lspci ?

Cordialement

#11 Re : -1 »  Capture son impossible avec RecordMyDesktop [Résolu] » Le 18/07/2014, à 00:14

temps
Réponses : 13

Bonjour,
Peut-être essayer la solution de J5012, d'expérience je sais qu'il est facile parfois de passer plusieurs jours sur une carte audio.
Si je n'ai pas répondu ou continué, c'est que je ne connais pas cette carte audio.
peut-être en faisant une recherche sous qwant avec les termes ubuntu et la carte des indications utiles apparaîtront.

Cordialement

#12 Re : -1 »  [recTV] Enregistre la TV HD - besoin de testeurs chez Orange/Free » Le 30/06/2014, à 13:43

temps
Réponses : 4

Bonjour

place117@place117:~/.recTV$ ls
crontab.py  recTV-ico.png  recTV.png  recTV.py  stop_recTV_command.py
place117@place117:~/.recTV$ python recTV.py 
Traceback (most recent call last):
  File "recTV.py", line 25, in <module>
    import appindicator
ImportError: No module named appindicator
place117@place117:~/.recTV$ 

Premier test
Tout est dans le code

Intel® Core™ i7 CPU M 640 @ 2.80GHz × 4    64bit  ubuntu 14.04

Cordialement

#13 Re : -1 »  [recTV] Enregistre la TV HD - besoin de testeurs chez Orange/Free » Le 30/06/2014, à 14:13

temps
Réponses : 4

Bonjour,
Merci, deuxième test avec les dépendances indiquées tout est O.K.

J'ai pas plus de temps à l'instant, mais je vais allé tester un peu tout avec sous peu
En premier la ou je suis j'ai pas les adresses rtp des chaines.
Mais au test j'obtiens bien un fichier mkv, sans rtp avec no data

Merci

#14 Re : -1 »  [résolu] <QThread> choix run et start » Le 28/06/2014, à 06:15

temps
Réponses : 11

Bonjour,

Toujours sur Qt et les thread
j'ai jusqu'à présent utilisé soit des bash soit des fork afin d'ouvrir plusieurs thread en même temps (utilisation de plusieurs touches en même temps du piano virtuel que j'ai créé)

Mon outil fonctionne avec le fork qui appel une fonction placée en bas du fichier cpp,
est-ce quelqu'un sait comment remplacer d'une manière simple le fork par une fonction qthread qui ferai la même chose ?
Et qui bien sure s’exécuterait à une vitesse proche de celle du fork.
L’application actuelle est composée de 3 fichiers, le main, lafenetre.cpp et lafenetre.h
Dans lafenetre.cpp je dessine un clavier, je piste les cliques et les touches du clavier azerty, au premier appel d'une note je la synthétise en utilisant la technique que j'ai crée pour le projet BAUL (avec 3octets) et enfin je lance la lecture du fichier audio synthétisé (le tout est très léger avant d'avoir finit d'appuyer sur la touche on a déja entendue le son)

Cordialement

#15 Re : -1 »  lm3jo en deb version 1.1.1-4 » Le 21/04/2014, à 05:17

temps
Réponses : 7

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.

#16 Re : -1 »  lm3jo en deb version 1.1.1-4 » Le 26/04/2014, à 21:36

temps
Réponses : 7

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

#17 -1 »  Question sur le sens du terme libre. » Le 18/04/2014, à 08:00

temps
Réponses : 7

Bonjour,

J'aime bien l'intitulé Café Ubuntu, qui permet d'ouvrir une discution sans ambitions comme on pourrait l'avoir au café.
Je pense que pour pouvoir utiliser un terme, il faut en premier le définir, ensuite décrire son domaine de définition (ses limites) et enfin son usage.

En logique pure :
Prenons le cas du terme libre entendue dans le monde informatique, souvent il désigne que la personne donne les codes avec plus ou moins de restrictions selon la licence.
Mais comment peut-on parler de liberté associé à un terme de licence ?
Les deux termes sont incompatibles, en logique ils ne peuvent se trouver dans une même phrase autrement que pour s'opposer.

En logique appliquée :
Prenons le cas ou dans un domaine les codes donnés sont constuits sur une croyance monstrueuse qui abrutit et trompe les utilisateur. Mais ces codes sont donnés sous licence dite libre.
Est-il entendue par la que c'est la liberté d'abrutir ? Car en toute logique s'il est démontré que la technique utilisée trompe la raison, nous ne pouvons parler de libre au sens logique entendue dans la langue courante.

Prenons une caricature de logique appliquée :
Admetons qu'un tux écrive un code qui simplifie le fonctionnement d'une application, qu'il mette en ligne le code qui prouve sa proposition, mais qu'il ne mette pas son code sous une licence dite libre.
Au sens premier, au sens logique, être libre c'est ne pas vouloir tromper son prochain, c'est avoir l'esprit ouvert aux avancés, c'est placer les avancés au dessus des lois des licences, c'est placer le sens du terme libre au dessus du sens des lois des licences.
Est-ce qu'une personne ou même une entité qui refuserai de reconnaitre cette avancée sous prétexte de licence, et même pire continuerai à promouvoir des outils qui trompent la raison, pourrai encore être considér comme faisant partie du libre ?

En d'autre mots, est-ce que le libre, c'est pratiquer le libre en montrant les code, ou est-ce respecter les lois induites par le libre quitte à détruire l'esprit du libre et même pire, détruire la raison même d'être du libre ?

C'est bien une question de café, in vino veritas

#18 Re : -1 »  Question sur le sens du terme libre. » Le 18/04/2014, à 08:37

temps
Réponses : 7

Bonjour,
Merci pour la réponse.
Le sujet ne parle pas de bien ou de mal.
Le sujet ne parle pas de beau.
Le sujet essaie de rester dans la logique et de faire l'inventaire des possibilités sans proposer telle ou telle solution comme meilleure, il y a d'ailleurs de nombreuses licences qui prouve que l'inventaire est interessant au moins pour comprendre et pouvoir faire son propre jugement.
Il y a de nombreuses portes derrières comme :
Peut-on imposer une attitude d'homme libre à quelqu'un qui par force ne le peut pas ? ....
L'idée du fil est juste celle d'un archiviste currieux qui cherche à faire l'inventaire des actes possibles et de leurs conséquences.

Cordialement

#19 Re : -1 »  Question sur le sens du terme libre. » Le 18/04/2014, à 12:06

temps
Réponses : 7

Bonjour,
En premier merci pour les réponses et à la lecture je m'apperçois qu'un simple classement linéaire n'est pas possible.
Car en fait il y a plusieurs thèmes en inter-actions qui partent du même sujet, et toute approche manichéenne du sujet, ne ferai que déformer la réalité et tromper.
Force est de constater qu'un avis commun du groupe se détache clairement, il serait possible d'essayer de cerner la limite, si un cas général serait supérieur à la peception par rapport au cas particulier des licence, mais ce serait déja s'enfermer dans une vue limitée et l'approche n'en serait donc pas libre (honête d'un point de vue logique).

Dès que j'ai un peu plus de temps, je pense essayer de classer du général au particulier, sachant que les lois du général sont toujours supérieures et plus vrais que les lois particulières.
Ensuite je vais essayer de faire un inventaire des licences du libre, de comprendre la raison de leur existence, et de voir ou elle se range dans ce classement iner-actif.

Il y a une phrase remarquable qui m'a bien plu et je pense partir d'elle au centre des inter-actions

qui donne le plus de libertés, non pas aux logiciels mais aux utilisateurs

Cordialement

Codialement

#20 Re : -1 »  Question sur le sens du terme libre. » Le 19/04/2014, à 01:47

temps
Réponses : 7

Bonjour,
Pour reprendre le fil.
Le cas le plus général est celui qui donne le plus de libertés aux utilisateurs.
Ce qui entend que l'outil soit utile en exemple on ne donne pas une petite cuillère comme outil pour déplacer une montagne ou encore on ne donne pas un format audio qui imite quand on sait qu'on peut modéliser l'acoustique.
Ce qui entend que le libre va cherché à utiliser les meilleurs outils, et que nous ne pouvons considérer une entité qui ne respecte pas cette première loi générale comme entité prônant le libre.
Le limites de cette première loi générale sont, les connaissances du moment, on ne peut pas reprocher l'ignorance, mais on peut reprocher la croyance en quelque chose de faux après démonstration. Donc on peut reprocher un manque de recherche d'information. De fait le libre se doit d'être en recherche permanente d'informations pour respecter la loi générale première.
Une fois la loi générale première énoncée, nous pouvons aborder les lois particulières dans l'ordre de la plus générale (de la plus vrai) vers les lois de plus en plus particulières.
Nous sommes dans un monde commerciale, avec des licences, le libre va devoir s'adapter aux outils à sa disposition, en exemple de nombreuses applications libres utilisent des formats audio issus de mac ou microsoft, elles ne peuvent être pour autant considérées comme non libre.
En partant dans une autre branche particulière nous trouvons en équilibre avec la première loi particulière l'usage qui va de l'intervention gracieuse en install partie jusqu'à l'utilisation de l'outil pour rendre les autres hommes moins libres sous différents arguments de sociétés conceptuels (c'est la raison pour laquelle j'ai pris soin d'écarté du sujet le beau et le bien suite aux pratiques observées).

Je continuerai plus tard, il s'entend bien que l'homme ne peut se juger avec un système de comparaison et ce n'est pas pour rien que même dans les lois française il y a les jurisprudence plus fortes souvent que les textes. Car les textes comme les licences ne peuvent représenter qu'un cas particulier, et l'esprit est toujours soumis au cas le plus général.

J'essaierai de reprendre ces propositions plus tard, je retourne coder.
Cordialement

#21 Re : -1 »  Question sur le sens du terme libre. » Le 20/04/2014, à 04:32

temps
Réponses : 7

Bonjour,
Pour continuer le sujet sans prétention que la vérité soit ma perception dans un esprit de discussion de café. Je pense que pour pouvoir développer plus il faut ajouter des informations comme un prérequis. Je vais prendre l'acoustique car c'est le domaine sur lequel je code actuellement.

Si nous prenons les lois de l'acoustique que j'ai démontré il en ressort deux particularités qui vont avoir un lien avec le sujet de ce fil.
La première de ces deux particularités, la moins significative avec le fil, est que pour qu'une forme sonore existe, il faut qu'elle ne soit pas masqué, qu'elle ait une force suffisante et qu’elle ait un espace vide après pour pouvoir être mise en mémoire.

Par analogie, nous pouvons dire que pour que le libre fasse du libre, il faut qu'il identifie les savoirs les plus vrais du moment en écartant tout ceux qui trompent la raison. Le libre ne peut pas dire que tout est bon à condition que cela rentre dans la gamelle d'avoir donné les codes avec la licence actuelle.

La deuxième particularité des lois de l'acoustique que j'ai énoncé et qui a un rapport avec le fil du sujet, dit que le cerveau est saturé en permanence d'informations, et de manière à laisser le conscient fonctionner, le subconscient détruit sans autre forme d'analyse tout ce qui n'est pas coutumier ou encore tout ce qui n'a pas été transmis par l'intelligence d'un autre homme, Tout savoir évolué est forcément un travail sur la base d'un savoir précédent transmis par contact direct avec un autre homme.
Nous trouvons dans cette proposition un renforcement pour dire qu'il ne faut pas mettre n'importe quoi dans la marmite, car si la quantité de déchets est trop grande nous ne trouverons plus le vital, l'essentiel et nous perdons la raison même du libre.

De ces observations naît une troisième branche de la source en équilibre avec les deux premières énoncées plus haut dans le fil.
Les trois premières branches énoncées, je pense que nous pouvons aborder pourquoi, il faut éviter le beau.
Le beau va se trouver ici sous la forme d'une idée appliquée en exemple une forme de licence et une multitude qui valide. Le beau est ici une incohérence qui revient à dire un qui pense et une multitude qui obéit et ne serait qu'une forme de dictature de la pensée. Ce serait imposé à quelqu'un une condition d'abandon de son esprit pour avoir le droit de faire partie du groupe. C'est beau tous qui pense pareil, oui c'est beau que si cette pensée c'est construite sur le libre arbitre pas par la force ou le conditionnement.
Ainsi dans l'esprit est-il judicieux de reconnaître comme libre une fausse information sous prétexte de licence ?
Ainsi est-il judicieux de ne pas reconnaître comme libre quelqu'un qui donne les codes mais ne veut pas qu'ils servent à d'autres systèmes d'exploitations qu'à ceux qu'il juge libres ?

De ces observations, nous pouvons déja entrevoir que le meilleur système libre sera celui qui aura su le mieux maîtriser son contenue pour apporter le plus de liberté à ses utilisateurs. Bien que cette analyse sur les systèmes d'exploitations libres soit par l'effet et donc douteuse par rapport à une analyse par la cause, elle est peut être un début de compréhension des mécanismes de différentes licences énoncées plus tard dans le fil.

Cordialement

#22 Re : -1 »  [résolu] Comment générer des séries de 40 lettres » Le 14/04/2014, à 17:30

temps
Réponses : 10

Bonjour,

claudius01 a écrit :

@temps: Exemples et cas d'utilisation concis car je ne comprends pas l'expression des besoins ni des définitions comme formes premières ;-(

Afin d'éclaicir le cas, je vais donner plus de détails et aussi essayer de clarifier ma pensée.

L'environement est la BAUL qui construit une infinité de Go de fichiers audio piloté par 14 octets.

Dans un des mécanismes de la BAUL, j'utilise une fichiers texte constitué de séries de formes.
Les deux derniers octets (des 14) qui pilotent la BAUL servent pour le premier à dire combien de caractères sont lus, pour le second combien de fois la série de caractère est lu.

Quand j'ai utilisé les termes "formes premières" je les entendais comme une analogie à nombres premier, (quelques choses qui ne peut être reconstitué à l'aide d'autres formes de bases).

Quand je parle de mettre en équilibre, je respecte la logique des arts et sciences (CNAM) toujours agir en fonction du poids et de la mesure. D'ou la question sur le nombre de caractères par ligne par rapport à une nouvelle action qui ne pèse que 14 octets.

Cordialement

Cordialement

#23 Re : -1 »  [résolu] Comment générer des séries de 40 lettres » Le 14/04/2014, à 21:19

temps
Réponses : 10

Bonjour,
Je vais essayer d'expliquer par l'exemple :
soit une ligne de forme :
aabccbdd...
je veux lire une ligne de la forme
aabaabaab
je vais pouvoir utiliser la première ligne indiquée en donnant la valeur 3 au treizième octet pour dire qu'il faut lire que trois caractère de la ligne,
et la valeur 3 au quatorzième octet pour dire qui faut répéter la lecture de la ligne 3 fois.

autre exemple,
je veux la ligne :
bababababa

il me suffit de trouver une ligne de forme première commençant par ba et de donner la valeur 2 au treizième octet et la valeur de 5 au dernier octet

autre cas :
je veux la forme
abcddcddcddcddcd
je vais lire en premier une forme première commençant par abcd
ensuite je vais chercher une forme première commençant par dcd que je fais répéter avec le quatorzième octet

Ce qui intéresse dans la démarche, c'est de trouver la forme d'écriture la plus simple pour marier les différentes formes, tout en gardant tous les choix accessibles facilement.

lire les formes une à une serait un absolue bien lourd, écrire tous cas de lignes possibles serait un absolue bien contraignant, entre les deux nous apparaît les cas les plus simples qui permettent de percevoir et donc comprendre et par effet manipuler facilement toutes les méta associations facilement.

Cordialement

#24 Re : -1 »  [résolu] Comment générer des séries de 40 lettres » Le 18/04/2014, à 15:26

temps
Réponses : 10

Bonjour,
Je poste en résolu.
le code pour donner les différentes formes sur 4 cas avec des ligne de 40 caractères a été donné.
Pour ceux qui n'ont pas vu la solution, plus en détail, cela donne 24 lignes représentants les 24 alignements possibles des cas les un par rapport aux autres
ABCD
ABDC
ACBD
ACDB
ADCB
ADBC
puis id en commençant par les 3 autres lettres soit 24 lignes
Ensuite la gestion des formes finales créant les 40 caractères ou même plus se fait à l'aide de l'application qui va dire combien il faut prendre de caractères et combien de fois il faut boucler la ligne de caractères.
En cas de forme première, c'est une nouvelle demande de lecture 14 octets qui est créée.
Pour éviter d'éventuels appels il est possible de développer d'autres lignes sur cette forme puisque les fichiers textes sont prévus pour 256 lignes.

Cordialement