Contenu | Rechercher | Menus

Annonce

Le forum rencontre en ce moment quelques soucis de charge, il est possible qu'une erreur soit affichée quand vous postez un message, ne rechargez pas la page au risque de poster une seconde fois votre message

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".

nombre réponses : 25

#0 Re : -1 »  vlc sous kubuntu » Hier à 23:14

temps
Réponses : 6

cliquer sur le dash et écrire dans l'invite qui s'ouvre muon
ou en terminal faire Ctrl+alt+T et écrire muon

#1 Re : -1 »  vlc sous kubuntu » Hier à 23:24

temps
Réponses : 6

Je suis sous kubuntu, le terminal marche, mais je suis pas sure que mon kubuntu ait quelque chose de standard force de tester.
Cordialement

#2 Re : -1 »  Camescope HD, fichier M2TS, montage DVD » Hier à 21:21

temps
Réponses : 1

Très bon format, j'enregistre sur 4 satellites depuis des années avec en utilisant kaffeine.
Je ne comprends pas pourquoi vouloir mettre en format DVD ? à la limite je serai plus pour du m4v avec ghb
Pour DVD il y a ffmpeg
Cordialement

#3 -1 »  Nouveau synthétiseur musical » Le 17/05/2013, à 19:12

temps
Réponses : 3

Bonjour,
J'ai créer un synthétiseur vocal ici mais il est facile de la transformer en synthétiseur musical, pour cela il suffit d'écrire des suites de lettres sans chercher à faire des mots. Il est aussi possible de remplacer les sons des lettres de la bibliothèque par des sons d'instrument de musique, ainsi chaque lettre du texte représentera une note d'un instrument, et la lecture d'un texte, donnera une mélodie.
Pour ceux qui ont envie de découvrir de nouveaux sons , de tester par curiosité, je suis avide de retours d'informations.
Cordialement

#4 Re : -1 »  Nouveau synthétiseur musical » Le 18/05/2013, à 17:19

temps
Réponses : 3

Bonjour,
Je viens d'ajouter en téléchargement une version ou j'ai remplacé les sons des lettres par les sons d'instruments de musique. La lecture d'un texte cré ainsi automatiquement une mélodie, mais bien sur le mieux est de faire ou retoucher la bibliothèque de sons à sa convenance, c'est facile, ce ne sont que quelques chiffres à modifier soit avec les outils que je donne, soit avec ghex directement en ouvrant le fichier en .jo
Cordialement

#5 Re : -1 »  Nouveau synthétiseur musical » Hier à 01:27

temps
Réponses : 3

Bonjour,
Merci pour l’intérêt. Pour les réponses :

Est ce une application similaire à Gespeaker ??

Non, le concept de cette application est un outil de créations et de partage de notre environnement avec ceux ne possédant pas tous nos moyens.

Pour l'installation : quelle est la procédure (penser aux novices) ??

Pour l'instant il n'y en a pas encore, il faut au moins connaître comment lancer une application en ligne de commande. Mais c'est une chose facile à faire, un tux peux changer ça en une demie heure, un habitué linux en suivant les tutos en quelques heures.
Ma démarche n'est pas de donner quelques chose de tout fait, car cela abrutirai, ma démarche est de partager les idées, les concepts, les sons, les manières de créer.
Sinon après quelques temps, il y a toujours wikipedia qui me traite de fou mais qui reprends mes concepts en les déformant légèrement et en les accordant à d'autres, c'est juste une histoire de temps qu'ils trouvent une mauvaise adaptation à leurs croyances actuelles. Comme ils avaient fait avec Einstein pour Poincaré, wikipedia garde la technique avec moi depuis 2002, même ide, même technique, pas de vague dans l'ordre établit. Mais aussi pas de créations, pas de créations de richesses...

As tu des exemples,extraits sonores, à nous faire écouter ??

J'en ai créé quelques uns mais c'est bien plus simple de donner le texte en lettre et laisser les appli faire les morceaux musicaux. J'ouvrirai un compte sur dogmazic et j'y placerai des passage en CC, un simple petit poème fait 26 mn de musique expérimental. Dogma car mon serveur ne fait pas streaming.
Pour revenir au synthétiseur vocal, j'aime bien le son rap produit par Bonjour kkkakkaklmlmlm.    ou pour le synthétiseur musical les jeux de sons sur les premières lettres  a aa bab abcd.
Je préfère donner des fichiers textes car depuis trois ans que j'ai créé ce format audio, régulièrement mes créations audio sont montré du doigt sous prétexte que certains sons existeraient déjà et seraient protégé par droit d'auteur !!! Il faut l'entendre, c'est comme si j’avais pas le droit d'ouvrir les yeux sous prétexte qu'un autre a déja ouvert les siens ! En plus j'imite pas, je crée en associant les lois des fronts avec des codes que j'ai inventé, plusieurs causes peuvent avoir le même effet, mais malgré cela j'ai déja eu pas mal de courrier en 3 ans.

Il existe des coïncidences étranges, depuis que j'ai donné les lois des ondes audio, il y a presque trois ans et demi, les autres synthétiseur vocaux ce sont bien amélioré bien que je ne sois jamais cité il est fort possible qu'une partie de mes info soit dans les codes cachés.
Cordialement

#6 Re : -1 »  [13.04] plus de son / pas de trace d'alsa » Le 18/05/2013, à 18:58

temps
Réponses : 3

J'ai déja rencontré ça, il y a longtemps.
Il suffit de faire ce qui est demandé. De désinstaller la librairie, ensuite de réparer les paquets cassés, ensuite installer la bonne librairie.
Je me souvient du principe, mais pas des lignes entrées en terminal, mais en cherchant un peu sur le forum, il me semble que j'avais donné le truc.
Cordialement

#7 Re : -1 »  [13.04] plus de son / pas de trace d'alsa » Le 18/05/2013, à 22:24

temps
Réponses : 3

Je pencherai plus pour une mise à jour automatique.
Je me souviens que ce passage s’effectue en 2 temps.
Cordialement

#8 -1 »  [résolu] Nouveau problème de trie avec des switch en langage C » Le 10/05/2013, à 05:35

temps
Réponses : 12

Bonjour,
Je reviens avec un problème de trie avec des switch c'est une évolution du premier problème rencontré que j'ai résolu.
Pour rappel nous avons une suite  de valeurs qui donnent des sorties différentes selon comment elles sont associées, parfois une valeur suffit, selon la valeur lu parfois il faut aller lire une ou deux valeurs après pour savoir la sortie.
La solution que j'ai proposé et qui marchait avant que je développe tous les cas, est que je mettais en mémoire à l'aide d'un switch une valeur actif qui me permettait de faire le trie.

Quand j'ai créé le cas valeur 1 suivit de la valeur 2 donne et ensuite valeur 2 suivit de la valeur 1 donne, le cas 1 passe par dessus le cas 2 dans le switch, normalement cela ne devrait pas gêner, mais quand je teste je m’aperçois que si j'utilise cet événement aux milieux d'autres événements tout va bien,  si je l'utilise seul tout va bien, mais si je boucle l'événement 1, l'événement 2 s'introduit ! Alors même que nous devrions être dans le switch actif actionné et l'événement 2 ne devrait pas apparaitre.
Est-ce que quelqu'un a une ide de pourquoi ? Ou comment mettre une sécurité pour qu'une sortie autre ne se glisse dans celle désirée ?

Cordialement

#9 Re : -1 »  [résolu] Nouveau problème de trie avec des switch en langage C » Le 11/05/2013, à 01:47

temps
Réponses : 12

Merci pour la réponse.
J'ai posté juste après avoir modifier mon code pour essayer de le rendre plus claire, en essayant de regrouper les différents niveaux de switch par lettre (qui sont mes variables).
Je viens de relire le code et j'avais placé un case 13 à la place d'un case 12 dans le switch qui permet de gérer les variations de cas possibles (l'un est le premier niveau de dérivée d'une lettre, l'autre son deuxième niveau).
En fait le trie par switch fonctionne très bien, c'était une faute d’inattention, mais pour mieux exprimer voici les deux bouts de code qui mal liés m'avaient posé problème

/***************************************************************************************************************************/
	case 8 : /*lettre i et ses sons dérivés de premier ordre*/
	actif = 12;
	break;/**fin lettre i */			
/***************************************************************************************************************************/

On voit bien que pour appeler la lettre i en dessous c'est le cas 12, mais avant modification pour rendre mon code plus visible, c'était le cas 13 et sur le code au dessus j'avais laissé actif = 13, en mettant comme indiqué j'ai fait disparaître le son "é" qui apparaissait comme par miracle dès qu'on avait un d après le "i" et que j'avais accordé à tord au maillage des switch

/***************************************************************************************************************************/
/***************************************************************************************************************************/
case 12 :/********switch actif 12 developpement des son i  *********************/
actif = 1;
	switch (assemblage1) {

/***debut son ie vers eau dérivée d'ordre 2****/
	case 4 :
	actif = 13;
	break;/**fin de la dérivée première lettres ie*/

/***************************************************************************************************************************/

/***debut son in*****/
	case 13 :

		fichierjo1 = NULL;
  		fichierjo1 = fopen("in.jo", "rb"); 
  		if(fichierjo1 == NULL){ 
    		printf("Ce fichier ne va pas %s\n","in.jo");
    		exit(1);
		}
  		fichiertampon1 = fopen(construit, "ab"); 
  		if(fichiertampon1 == NULL){ 
    		printf("Ce fichier ne va pas %s\n",construit);
    		exit(1);
  		} 
		if (fichierjo1 != NULL)
		{
		if (fichiertampon1 != NULL)
		{
		abadie = fgetc(fichierjo1); 
		while (abadie != EOF){
		fwrite(&abadie,1,sizeof(regle),fichiertampon1);
		abadie = fgetc(fichierjo1);
		}
		}
		}
		fclose(fichiertampon1), fichiertampon1 = NULL;;
		fclose(fichierjo1), fichierjo1 = NULL; 
		actif = 1;

	break;/******* fin son in  ****************/
/***************************************************************************************************************************/
	default :/****son i seul*********************/
		fichierjo1 = NULL;
  		fichierjo1 = fopen(ja9, "rb"); 
  		if(fichierjo1 == NULL){ 
    		printf("Ce fichier ne va pas %s\n",ja9);
    		exit(1);
		}
  		fichiertampon1 = fopen(construit, "ab"); 
  		if(fichiertampon1 == NULL){ 
    		printf("Ce fichier ne va pas %s\n",construit);
    		exit(1);
  		} 
		if (fichierjo1 != NULL)
		{
		if (fichiertampon1 != NULL)
		{
		abadie = fgetc(fichierjo1); 
		while (abadie != EOF){
		fwrite(&abadie,1,sizeof(regle),fichiertampon1);
		abadie = fgetc(fichierjo1);
		}
		}
		}
		fclose(fichiertampon1), fichiertampon1 = NULL;;
		fclose(fichierjo1), fichierjo1 = NULL; 
		actif = 1;
		goto remonteswitch ;
		break;
	}/* fin switch (assemblage1)*/


break;/**fin du cas 2**/
break;/******************************************bloc  fin derivé du son i ****************************/
/***************************************************************************************************************************/
/***************************************************************************************************************************/
case 13 :/********switch actif 13 dérivée de deuxième ordre des son ie  **************************************/
actif = 1;
	switch (assemblage1) {

/***debut son ied ier****/
	case 3 :
	case 17 :

		fichierjo1 = NULL;
  		fichierjo1 = fopen(ja9, "rb"); 
  		if(fichierjo1 == NULL){ 
    		printf("Ce fichier ne va pas %s\n",ja9);
    		exit(1);
		}
  		fichiertampon1 = fopen(construit, "ab"); 
  		if(fichiertampon1 == NULL){ 
    		printf("Ce fichier ne va pas %s\n",construit);
    		exit(1);
  		} 
		if (fichierjo1 != NULL)
		{
		if (fichiertampon1 != NULL)
		{
		abadie = fgetc(fichierjo1); 
		while (abadie != EOF){
		fwrite(&abadie,1,sizeof(regle),fichiertampon1);
		abadie = fgetc(fichierjo1);
		}
		}
		}
		fclose(fichiertampon1), fichiertampon1 = NULL;;
		fclose(fichierjo1), fichierjo1 = NULL; 
		fichierjo1 = NULL;
  		fichierjo1 = fopen("ai.jo", "rb"); 
  		if(fichierjo1 == NULL){ 
    		printf("Ce fichier ne va pas %s\n","ai.jo");
    		exit(1);
		}
  		fichiertampon1 = fopen(construit, "ab"); 
  		if(fichiertampon1 == NULL){ 
    		printf("Ce fichier ne va pas %s\n",construit);
    		exit(1);
  		} 
		if (fichierjo1 != NULL)
		{
		if (fichiertampon1 != NULL)
		{
		abadie = fgetc(fichierjo1); 
		while (abadie != EOF){
		fwrite(&abadie,1,sizeof(regle),fichiertampon1);
		abadie = fgetc(fichierjo1);
		}
		}
		}
		fclose(fichiertampon1), fichiertampon1 = NULL;;
		fclose(fichierjo1), fichierjo1 = NULL; 
		actif = 1;

	break;/******* fin son ied ier  ****************/
/***************************************************************************************************************************/
/***debut son ien****/
	case 13 :
		fichierjo1 = NULL;
  		fichierjo1 = fopen(ja9, "rb"); 
  		if(fichierjo1 == NULL){ 
    		printf("Ce fichier ne va pas %s\n",ja9);
    		exit(1);
		}
  		fichiertampon1 = fopen(construit, "ab"); 
  		if(fichiertampon1 == NULL){ 
    		printf("Ce fichier ne va pas %s\n",construit);
    		exit(1);
  		} 
		if (fichierjo1 != NULL)
		{
		if (fichiertampon1 != NULL)
		{
		abadie = fgetc(fichierjo1); 
		while (abadie != EOF){
		fwrite(&abadie,1,sizeof(regle),fichiertampon1);
		abadie = fgetc(fichierjo1);
		}
		}
		}
		fclose(fichiertampon1), fichiertampon1 = NULL;;
		fclose(fichierjo1), fichierjo1 = NULL; 
		fichierjo1 = NULL;
  		fichierjo1 = fopen("in.jo", "rb"); 
  		if(fichierjo1 == NULL){ 
    		printf("Ce fichier ne va pas %s\n","in.jo");
    		exit(1);
		}
  		fichiertampon1 = fopen(construit, "ab"); 
  		if(fichiertampon1 == NULL){ 
    		printf("Ce fichier ne va pas %s\n",construit);
    		exit(1);
  		} 
		if (fichierjo1 != NULL)
		{
		if (fichiertampon1 != NULL)
		{
		abadie = fgetc(fichierjo1); 
		while (abadie != EOF){
		fwrite(&abadie,1,sizeof(regle),fichiertampon1);
		abadie = fgetc(fichierjo1);
		}
		}
		}
		fclose(fichiertampon1), fichiertampon1 = NULL;;
		fclose(fichierjo1), fichierjo1 = NULL; 
		actif = 1;

	break;/******* fin son ien  ****************/

/***************************************************************************************************************************/
	default :/****son ie seul****************/
		fichierjo1 = NULL;
  		fichierjo1 = fopen(ja9, "rb");
  		if(fichierjo1 == NULL){
    		printf("Ce fichier ne va pas %s\n",ja9);
    		exit(1);
		}
  		fichiertampon1 = fopen(construit, "ab");
  		if(fichiertampon1 == NULL){
    		printf("Ce fichier ne va pas %s\n",construit);
    		exit(1);
  		}
		if (fichierjo1 != NULL)	{
		if (fichiertampon1 != NULL){
		abadie = fgetc(fichierjo1);
		while (abadie != EOF){
		fwrite(&abadie,1,sizeof(regle),fichiertampon1);
		abadie = fgetc(fichierjo1);
		}
		}
		}
		fclose(fichiertampon1), fichiertampon1 = NULL;;
		fclose(fichierjo1), fichierjo1 = NULL;
		actif = 1;
		goto remonteswitch ;
		break;
	}/* fin switch (assemblage1)*/


break;/**fin du cas 2**/
break;/*********************bloc  fin switch actif 13 dérivée de deuxième ordre des son ie ****************************/

Cordialement

#10 Re : -1 »  [résolu] Nouveau problème de trie avec des switch en langage C » Le 12/05/2013, à 22:11

temps
Réponses : 12

Bonjour,
Oui, mais le traitement aurai été beaucoup plus lourd, car il prendrait en charge des cas imaginaires qui n'existent pas dans la réalités, et ajouterait des règles à la prononciation de la langue française qui en possède déjà bien assez. L'important n'est pas la position dans le mot, l'important est l'environnement direct qui indique quel son prononcer.
J'ai écrit le code sous cette forme car l'objectif final est d'avoir dans la bibliothèque que les sons de base des voyelles (séquences de fronts) et aussi des fausses consonnes comme le "s", ensuite de modifier le début du son de base pour obtenir les différentes consonnes directrices. L’écriture en langage C de la langue française  est à peu près au même niveau de facilités que celle de l'écriture des segments de fronts acoustiques, mais possède un avantage certain, c'est la pratique quotidienne qui nous indique comment associer les lettres pour avoir tel ou tel son.
Je poste en résolu, car je viens de m’apercevoir que j'avais oublié.
Cordialement

#11 Re : -1 »  [résolu] Nouveau problème de trie avec des switch en langage C » Le 13/05/2013, à 19:26

temps
Réponses : 12

Merci pour l'info, je vérifierai, mais j'ai un doute, car quand j'ai démarré le projet il y a presque trois ans, je n'ai rencontré que des croyances étranges et des codes introuvables qui en plus ne permettaient pas de modifier facilement les sons.
Cela fait trois ans que je postes sur les lois des sons, peut-être même que cela a aidé d'autres projets, mais je suis sure que ma technique de modélisation est à des années lumières de ce que j'ai trouvé quand j'ai regardé, car le reste est construit sur des croyances fausses, donc impossible de rivaliser avec le vrai que je présente.

Est-ce que  espeak arrive à écrire une lettre avec 72 octets ? avant compression ? car le future est à la technologie bas cout, faible consommation, intégrable sous la peau ou en diverses lieux. Si espeak l'executable pèse plus de 30 ko, et possède une bibliothèque de plus de quelque centaines de Ko, il n'existe déja plus, il n'aura été qu'une étape de plus dans la construction d’incohérences. Car ça fait plus de trois ans que j'indique comment se construisent les sons même si le monde reste sourd et continue à parler fréquences, fouretout ou foureriez et autres.

De plus derrière il y a beaucoup plus, il y a un synthétiseur de musique, il suffit de remplacer les sons dans la base et chaque texte devient une mélodie.

De plus, de plus, si mon appel de fond aboutie, il y a la carte audio linux, la carte audio linux couplé à un casque neuronal. Est-ce que espeak ouvre la porte aux découvreurs ? ou la ferme-t-elle ?

Quand on utilise mon synthétiseur vocal, qu'on assemble ses fronts pour créer le son de sa lettre, ce n'est pas un enregistrement trafiqué, c'est une voix toute droit sortie de notre imagination est-ce que  espeak  apporte ça ?

Cordialement

#12 Re : -1 »  [résolu] Nouveau problème de trie avec des switch en langage C » Le 15/05/2013, à 13:22

temps
Réponses : 12

"etre testeur" sont des mots qui font plaisir, jusqu'à maintenant tous ceux qui ont testés ont validés mes affirmations mêmes si celles-ci ne correspondent pas aux croyances.
Détaillé mon écrit ne serait qu'un discours portant à polémiques, il suffit des tester et voir si j'affirme à tord ou à raison.
Je termine d'expliquer les segments de fronts de chaque lettre, ensuite je m'occuperai de faire une bibliothèque ou tous les fronts de lettres se lient bien entre eux, car actuellement j'ai mis dans la bibliothèque que des fronts pour lettres seules, mon ancienne priorité étant de travailler sur la langue, et avant d'affiner cette partie j'avance un peu sur l'autre.
J'ai eu un message hier après-midi d'un docteur en science "conception informatique" qui a regardé et testé, si j'ai bien compris il va faire évoluer mon projet de son coté pour des applications pour handicapés, mais j'en sais pas plus à part qu'il a eu la courtoisie de me prévenir et de me remercier pour mon travail.
Cordialement

#14 Re : -1 »  [résolu] Nouveau problème de trie avec des switch en langage C » Le 15/05/2013, à 22:23

temps
Réponses : 12

Il faut que j'aille voir, je me souviens du titre que c'est dans un "truc" d'informatique, j'ai déduit le terme "conception informatique" que j'ai d’ailleurs placé entre guillemets, en fait j'accorde si peu d'importance à cet aspect (pour moi un homme == un homme, certains ont peut être plus de facilités mais le terme == reste cf Laplace et sa définition des titres en science).
Je viens de faire une petite vidéo car par hasard en ajustant les premiers fronts du son "é" (grande différence comme pour les consonnes directrice), j'ai trouvé un effet pas mal, et j'en ai fait une vidéo, et je remets à demain l'explication du son "é" qui est remarquable. La vidéo est ici

le texte qui donne le fond sonore de la vidéo est placé dessous

é é é éé aaaiiiaaauuuaaaeeeaaa é é é éé aaaiiiaaauuuaaaeeeaaa é é é éé kkkakkaka é é é éé é é é éé aaaiiiaaauuuaaaeeeaaa é é é éé aaaiiiaaauuuaaaeeeaaa é é é éé kkkakkaka é é é éé kkkkkiiikkkkikkkikkik é é é éé ssisso  é é é éémmllpppppppppppddddiddddodddadddde é é é éé kkkakkaka é é é éé vplmvmplllajjjhggggttrrrra é é é éé é é é éé aaaiiiaaauuuaaaeeeaaa é é é éé aaaiiiaaauuuaaaeeeaaa é é é éé kkkakkaka é é é éé é é é éé aaaiiiaaauuuaaaeeeaaa é é é éé aaaiiiaaauuuaaaeeeaaa é é é éé kkkakkaka é é é éé kkkkkiiikkkkikkkikkik é é é éé ssisso  é é é éémmllpppppppppppddddiddddodddadddde é é é éé kkkakkaka é é é éé vplmvmplllajjjhggggttrrrra é é é éé 

A et un truc important pour la construction de vos lettres, il faut faire attention de toujours décaler vos segments de fronts autrement la répétition de vos segments de front prennent le pas sur votre son car les liens entre groupe de segments auront plus de force du fait de la répétifion. Donc quand nous répétons un groupe de segments il ne faut pas le mettre au même niveau par rapport à la pression d'équilibre (le milieu). C'est dit en d'autres mots quand je parle des forces des fronts, mais cet effet particulier est à surveiller dans nos constructions de lettres.

Cordialement

#15 -1 »  |résolu] Trie avec des switch en langage C » Le 30/04/2013, à 20:43

temps
Réponses : 5

Bonjour,
Je cherche la meilleure méthode pour faire un trie à l'aide de switch.
Je lis des données qui sont écris avec 5 caractères
switch
case : 0 ... case 4
mais le troisième caractère est particulier car il représente le troisième caractère que quand il est suivit du premier ou du cinquième.
Quand il est suivit du deuxième c'est un sixième cas, et quand il est suivit du quatrième caractère c'est un septième cas.

L'idée première qui me viens est de mettre en amont du switch une zone tampon composé de deux variables
La première variable qui va servir à indiquer le dernier caractère lu, et la deuxième variable qui va indiquer au switch dans quel case aller.

Ensuite créer à l'intérieur du case 2, celui du troisième caractère un nouveau switch reprenant les cas possibles

Ma question est que si cela est facile à faire avec 5 caractères le système sur lequel je travaille en contient beaucoup plus, et de manière à ne pas avoir un code trop long, je me demande s'il est possible de boucler dans le switch les cas ou les caractères sont indépendants.

En d'autres mots revenir au début de la fonction sans que celle-ci ait eu le temps de se terminer ? Un saut comme dans le basique.

Cordialement

#16 Re : -1 »  |résolu] Trie avec des switch en langage C » Le 30/04/2013, à 23:37

temps
Réponses : 5

J'ai commencé à imaginer la forme, ce serait un peu dans ce genre :

remonteswitch : 

	switch (actif) {
case 1 :
 
	switch (position) {/* debut switch (position)*/ 
case 1 :
    printf("la position est %d\n",position);
break;
case 2 :
    printf("la position est %d\n",position);
break;
case 3 :
	actif = 2;
	ancienposition = position;
break;
case 4 :
    printf("la position est %d\n",position);
break;
case 5 :
    printf("la position est %d\n",position);
break;
}
case 2 :

switch (position){
case 1 :
case 5 :
    printf("la position est %d\n",ancienposition);
actif = 1;
goto remonteswitch ; 
case 2 :
    printf("la position est %d\n",6);
actif = 1;
break;
case 4 :
    printf("la position est %d\n",7);
actif = 1;
break;

}

break;
}

Qu'en pensez-vous ?

Pour plus de détails, ce n'est pas un exercice théorique, dans le synthétiseur vocal que j'ai créé, je prononce chaque lettre, mais parfois le même son s'écrit avec plusieurs lettres, en exemple le "o" seul est le son "o" mais suivit de "i" ou"n" ou "u" deux lettres donnent un seul son.

Pour défendre le goto, si nous cherchons sur la toile dans les cours la plupart ne veulent pas que celui-ci soit utilisé, quoique j'ai cru lire un jour que LT le défendait, ceci est une démonstration par l'effet. Plus sérieusement par la cause, en fait nous modélisons des systèmes physiques qui sont régit par plusieurs dimensions en équilibres et chaque dimension possède ses propres lois, nous analysons ces états d'équilibres à l'aide de notre cerveau qui analyse la position du système en fonction d'une multitude d'interactions entre les différentes dimension. En prenant un cas simple, seulement 5 dimensions, nous voyons bien que notre cerveau lie chacune de ces dimension directement aux autres, c'est pourquoi le goto est utile car c'est dans notre mode de penser que nous percevons des cas possibles et ceux-ci ne peuvent être liés à un point central, mais peuvent être seulement perçu dans un tout.

Cordialement

#17 Re : -1 »  |résolu] Trie avec des switch en langage C » Le 01/05/2013, à 10:45

temps
Réponses : 5

Bonjour,
J'ai testé la solution proposée et ça marche mais ça ne marche pas.
En fait le goto fonctionne très bien, mais est limité dans le nombre de switch qu'il peut traverser, en fait c'est comme un "break", ça sort du switch ou on est, pas de tous les switch imbriqués.
Les solutions que j'imagine sont :
Soit j'abandonne le fichier d'entete dans le format audio jo, ce qui va diviser le code par deux, supprimer pas mal d'action de filtrage pour retirer les entete des fichiers qui se concatennent dans la zone tampon, mais surtout enlever les switch de position.
Soit je fait un goto par switch rencontré, en fait ce serait un goto, qui envoie vers un autre goto qui envoie vers un goto qui arrive à la destination finalequi est le début de la fonction.
Je regarderai ça ce week-end
Cordialement

#18 Re : -1 »  |résolu] Trie avec des switch en langage C » Le 01/05/2013, à 12:54

temps
Réponses : 5

Bonjour,
J'ai lu ton message, et je suis aller voir mon code pour être sure parce qu'après tout c'est peut-être possible ce que tu dis.
Et voici et voila, le goto passe bien plusieurs switch, en premier j'ai testé s'il passait bien plusieurs if, ce qui est le cas, j'ai remplacé mes switch par des if, et la même effet, c'était ma manière de tester un code non fini qui m'a fait croire que le goto ne passait pas plusieurs switch.
En fait mon code est très simple, il est composé de quatre fonctions très simple , une qui lit le texte, une qui identifie le son à concaténer dans le fichier tampon selon la lettre lu, une qui adapte le fichier audio dans la zone tampon au format des cartes audio d'aujourd'hui, et une qui lance sox pour lire le fichier audio.
Le code fait des milliers de lignes mais c'est toujours la même tache qui se répète pour chaque lettre, et après encore la même tache selon que la lettre soit en début de mot pour garder l'entête. En fait le concept est très simple, c'est juste la quantité d'informations qui lui donne un aspect de complexité qui n'existe pas. C'est un peu comme quand on crée nos sons de bases par lettre, quand on regarde les effets ça a l'air complexe, mais quand on les construit avec les causes c'est évident.

Je poste en résolu.

J'ai regardé un peu la doc sur lex, sur l'instant je suis pas trop attiré.
En fait comme je l'ai écrit c'est la même tache repris un grand nombre de fois. A l'instant t le code source fait dans les 2900 lignes, il doit bien y en avoir 400 lignes vides.
Si je n'écris plus les entetes dans les fichiers audio de la base de données (très facile à réaliser), le code tombe à 1200 lignes utiles. Si au lieu d'écrire une multitude de fois la même tache je fais une fonction par tache qui se répète, le code va tomber à 200 ou 300 lignes utiles. Peut-être qu'un jour je m'y mettrai mais je doute, en ce moment je pense plus à créer une base de données des sons français, celle que j'ai je l'ai écrite en moins d'une heure, et en exemple dans oi.jo il y a plein de "0" c'est impossible d'avoir un front d'une durée "0" d'ou bug, d'ou il faut que je vérifie ce que j'ai mis dedans. Ensuite si j'ai une version française, il faut que je trouve un néerlandais pour pouvoir faire une base de données adapté aux Pays-Bas, ensuite tel ou tel accent régional, ensuite d'autres pays, d'autres langues selon mes rencontre. Je trouve du plaisir à construire les sons et à la limite dès qu'un outil fonctionne pour moi, c'est suffisant. Je trouve plus important et plus plaisant à l'esprit de faire des bibliothèques qui pourront être utiles pour ceux qui ont perdu la voix ou l'audition que de travailler sur l'amélioration (tablette qui dit ce qu'il a écrit d'avance, ou ce qu'il écrit, un  simple appui) de l'outil.

Cordialement

#19 Re : -1 »  |résolu] Trie avec des switch en langage C » Le 08/05/2013, à 07:09

temps
Réponses : 5

Bonjour,
Je ne vais peut-être pas utiliser la technique qui modifie le début des sons des voyelles pour obtenir les consonnes. directrices car cela prendrai plus de ressource que de concaténer une consonne directrice directement. Prenons le cas de la lettre "B", si nous plaçons directement la consonne directrice avant le son de la voyelle, celui-ci sera peut-être déformé ou encore inaudible. Il faut lui donner un petit espace avant pour que les fronts précédents (des lettres précédentes) ne le déforme pas. Après avoir donné ce petit espace le son "B" produit par la lettre "B" ne pèse que 72 octets et je peux réduire encore. En fait concaténer 72 octets sera toujour plus rapide que d'aller modifier le fichier tampon.
En preuve voici en ascii les 72 valeurs des fronts (amplitude/durée) qui prouve pour ceux qui veulent tester.

133 28
132 171
116 115
130 162
126 30
132 100
116 110
136 103
130 61
136 91
115 104
143 112
121 111
129 27
101 100
136 72
116 70
133 28
100 165
164 61
118 57
146 60
89 159
177 59
108 53
122 22
119 11
163 27
116 49
120 12
100 25
107 15
105 3
107 6
71 40
128 29

Je ne sais pas combien pèse les autres syntétiseur vocaux sous linux et leur qualité.
Mais ici nous avons une bibliothèque qui se pèse en centaine de Ko pas plus et un executable en ko, idéal sur des petits systèmes sous linux ,embarqué genre raspberry pi. Le plus lourd ce sont les voyelles dès que j'ai le temps je dois pouvoir réduire leurs poids par 10, les consonnes ne pèsent pas assez pour en parler.

De plus je me suis apperçu d'une erreur dans la bibliothèque actuelle. Les sons que j'ai mis sont correctes, ils fonctionnent très bien en les testant séparément, mais j'ai pas tenue compte que si on place la fin d'une voyelle trop près de la consonne qui suit, la voyelle devant détruit la consonne. Et quand j'ai testé en attachant les syllabe hier, j'ai pu m'appercevoir que ça n'allait pas. Je vais corriger, j'ai deux solutions, soit j’ajoute un blanc devant chaque consonne, soit un blanc à la fin de chaque voyelle, comme il y a moins de voyelles, j'opte pour la deuxième solution.
Cordialement

#21 -1 »  son quatrevingt-treize » Le 05/05/2013, à 17:31

temps
Réponses : 0

Bonjour,
Par pure hasard j'ai découvert une technique (qui existe peut-être déja fait autrement) pour donner une âme musicale à nos texte.
Je l'ai nommé son quatrevingt-treize.
La technique consiste à remplacer dans la bibliothèque des sons de base du synthétiseur vocal que j'ai créé le son des lettres par d'autres sons selon le style musical désiré.
Ainsi le synthétiseur vocal au lieu de lire un texte joue de la musique en fonction des textes rencontrés. Effets surprenant garantie, novateur ... c'est très fort.
Cordialement

#22 Re : -1 »  [résolu] CMU Sphinx reconnaissance vocale » Le 04/05/2013, à 10:37

temps
Réponses : 30

Bonjour,
Bien que l'idée est germée en 2009, que j'ai commencé à en parlé sur le forum en 2010, finalement j'ai pu la réaliser même si j'ai du tout reprendre au début (presque car sox fait le lien entre la ligne de commande et les cartes audio du moment).

Je poste sur ce fil pour dire que l'idée se concrétise et que j'ai mis en ligne une première version de synthétiseur vocal libre que sous linux.
Je viens tout juste d'écrire ce matin la notice d'utilisation en ajoutant le son "ch".

En controlant j'ai pu m’apercevoir qu'il est apparu un parasite à chaque début de lettre qui n'existait pas au début, je pense qu'il apparaît quand je concatene le fichier tampon, mais les sons restent audibles et maintenant que je l'ai vu je trouverai la cause et la corrigerai.

Tout retour d'information ou participation à la création ou amélioration des sons de base est la bienvenue (voix grave, aigue, enfantine, accent belge, régional ou canadien... toutes les richesses de notre langue

Je poste le message qui a ouvert le fil en résolu, puisque j'ai la solution

#23 Re : -1 »  [résolu] CMU Sphinx reconnaissance vocale » Le 04/05/2013, à 16:44

temps
Réponses : 30

Bonjour,
J'ai corrigé le code car le compteur qui filtre l'entete des fichier ne marche pas et cela produit 6  ondes de trops.
En d'autres mots, j'ai refais la bibliothèque sans entete en plus cela va diviser le code par 2.
Mais je ne peux pas encore le faire car la création des fichiers audio dans la zone tampon est beaucoup trop rapide, sox n'arrive pas à lire le fichier audio qu'un autre commence déja à se créer. Ja vais regardé comment récupéré dans sox que le fichier a fini d'être lu pour envoyer l'écriture du suivant en atendant je vais réduire la vitesse de lecture dans le main de l'application

Astuce, j'ai accordé par hasard en jouant des sons à la place d'une lettre, ça donne un effet pas mal comme une programmation de piano. Mais pour l'instant, j'ai pas le temps d'explorer cette voie.

Cordialement

#24 Re : -1 »  [résolu] Langage C pour la lecture d'un fichier » Le 28/04/2013, à 17:35

temps
Réponses : 12

Je vais reprendre le code d'identification des lettres car actuellement je rencontre un  problème avec les accents.
Si on regarde de plus près je lis le fichier texte en récupérant des int (des symboles construits sur des chiffres)
je manipule ces int pour les transformer en char (des symboles construits sur des lettres, c'est plus lourd)
ensuite j'envoie l'information dans la fonction de traitement pour savoir quel son il faut prononcer,
dès que la fonction récupère les char elle fait en premier une boucle de manière à tout remette en int pour pouvoir gérer les switch d'actions.
Au passage de ces manip, mes accents deviennent des "0" soit des sons "A" dans ma boucle d'identification.

En d'autres mots, je transforme les int que je récupère en char pour ensuite faire un boucle pour les retransformer en int, autant envoyer directement des int dans la fonction de traitement, je vais donc entièrement reprendre le code la semaine prochaine.

Pour répondre aux cas de sémantique cités au début du fil, les sons "n" et " t " n'existe pas en eux même, il ne sont qu'une manière de commencer le son suivant, donc ils ne s'entendent pas quand on les place à la fin d'un verbe "couvent", si c'est un nom et que le son "an" doit être prononcé, il suffit de mettre en mémoire "actif" à chaque fois que nous avons un article "du""le" .. qui fait prononcé "en" "an". Je pense qu'avec quelque règles dans le switch, je dois pouvoir régler ça sans faire de sémantique.

En exemple de l'effet accent :

josi@josi:~/Abadiejoris/1$ ./synthe lit.txt 
la lettre lu est 115
indique-pos 18
la lettre lu est 195
indique-pos 0
la lettre lu est 169
indique-pos 0
la lettre lu est 32
indique-pos 26

joris.wav:

Le son s est 18 dans la boucle case 18 du switch, mais au début c'était déja un int
Le son "é" est 0 dans la boucle qui est normalement le son a, alors qu'il devrait être "28" dans a boucle, il lit 195 et 169 (deux int)
ensuite on retrouve bien l'espace 26 dans la boucle lu 32

En attendant la reprise tout en int, je place un filtre sur 195 et j'utilise d'autres symboles comme $ pour remplacer les accents.

Pour ceux qui reprennent la bibliothèque des sons de base, il faut faire attention que c'est un tout lié par plusieurs systèmes aux lois différentes en équilibre, en exemple si on crée son son "S" assez fort , les voyelles étant créées aussi assez fort donne le bon son "S", mais si on ajoute une voyelle prononcée moins fort, le son "S" devient un son "F"

Un autre exemple si on veut créer un espace sans son, il faut que celui-ci soit composé d'ondes aléatoires changeant de faible amplitude, car si nous reprenons le même front d'onde, nous lui donnons un force qui va être entendue comme un bruit de fond.

Cordialement