Lien pour entendre la sonnerie de téléphone créé au format son.jo
/**
*@ Andre pierre jocelyn
*@ andre@univ-montp2.fr
*@projet audio au format jo
*@ le format jo est un fichier de musique écrit en mode texte
*@A participe a la creation de ce script *@Frédéric Boulanger
*@frederic.boulanger@supelec.fr */

import javax.sound.sampled.AudioFormat;
import javax.sound.sampled.AudioSystem;
import javax.sound.sampled.LineUnavailableException;
import javax.sound.sampled.SourceDataLine;


public class LeO {

/** C ici que commence la construction des ondes
* chaque onde devra avoir son propre void, il suffit de copier coller
*en remplaçant le numéro de l'onde pour en créer une nouvelle
*/

//onde 1
public static void face1(double freq1, long duree1, SourceDataLine onde1) {
AudioFormat jo1 = onde1.getFormat();
float TauxEchantillon1 = jo1.getSampleRate();
int tailletampon1 = onde1.getBufferSize();
int tailleEchantillon1 = jo1.getSampleSizeInBits();
int nbOctets = 0;
int valMax1 = 0;
if (tailleEchantillon1 == 8) {
nbOctets = 1;
valMax1 = 0x7F;
} else if (tailleEchantillon1 == 16) {
nbOctets = 2;
valMax1 = 0x7FFF;
} else {
throw new Error("# Nombre de bits par échantillon non supporté : " + tailleEchantillon1);
}
boolean bigEndian = jo1.isBigEndian();
int nbEchantillons = (int)Math.ceil((double)duree1 / 1000 * TauxEchantillon1);
byte echantillonaudio1[] = new byte[tailletampon1];
int i = 0;
while (i ‹ nbEchantillons) {
int j = 0;
while ((j ‹ tailletampon1) && (i ‹nbEchantillons)) {
int val1 = (int)(valMax1 * base1(i++, freq1, TauxEchantillon1));
if (nbOctets == 1) {
echantillonaudio1[j++] = (byte)val1;
} else if (bigEndian) {
echantillonaudio1[j++] = (byte)((val1 & 0xFF00) >> 8);
echantillonaudio1[j++] = (byte)(val1 & 0x00FF);
} else {
echantillonaudio1[j++] = (byte)(val1 & 0x00FF);
echantillonaudio1[j++] = (byte)((val1 & 0xFF00) >> 8);
}
}
onde1.write(echantillonaudio1, 0, j);
}
}
// fin onde 1
//debut onde 2
public static void face2(double freq2, long duree2, SourceDataLine onde2) {
AudioFormat jo2 = onde2.getFormat();
float TauxEchantillon2 = jo2.getSampleRate();
int tailletampon2 = onde2.getBufferSize();
int tailleEchantillon2 = jo2.getSampleSizeInBits();
int nbOctets = 0;
int valMax2 = 0;
if (tailleEchantillon2 == 8) {
nbOctets = 1;
valMax2 = 0x7F;
} else if (tailleEchantillon2 == 16) {
nbOctets = 2;
valMax2 = 0x7FFF;
} else {
throw new Error("# Nombre de bits par échantillon non supporté : " + tailleEchantillon2);
}
boolean bigEndian = jo2.isBigEndian();
int nbEchantillons = (int)Math.ceil((double)duree2 / 1000 * TauxEchantillon2);
byte echantillonaudio2[] = new byte[tailletampon2];
int i = 0;
while (i ‹nbEchantillons) {
int j = 0;
while ((j ‹tailletampon2) && (i ‹nbEchantillons)) {
int val2 = (int)(valMax2 * base2(i++, freq2, TauxEchantillon2));
if (nbOctets == 1) {
echantillonaudio2[j++] = (byte)val2;
} else if (bigEndian) {
echantillonaudio2[j++] = (byte)((val2 & 0xFF00) >> 8);
echantillonaudio2[j++] = (byte)(val2 & 0x00FF);
} else {
echantillonaudio2[j++] = (byte)(val2 & 0x00FF);
echantillonaudio2[j++] = (byte)((val2 & 0xFF00) >> 8);
}
}
onde2.write(echantillonaudio2, 0, j);
}
}
//fin onde 2
//debut onde 3
public static void face3(double freq3, long duree3, SourceDataLine onde3) {
AudioFormat jo3 = onde3.getFormat();
float TauxEchantillon3 = jo3.getSampleRate();
int tailletampon3 = onde3.getBufferSize();
int tailleEchantillon3 = jo3.getSampleSizeInBits();
int nbOctets = 0;
int valMax3 = 0;
if (tailleEchantillon3 == 8) {
nbOctets = 1;
valMax3 = 0x7F;
} else if (tailleEchantillon3 == 16) {
nbOctets = 2;
valMax3 = 0x7FFF;
} else {
throw new Error("# Nombre de bits par échantillon non supporté : " + tailleEchantillon3);
} boolean bigEndian = jo3.isBigEndian();
int nbEchantillons3 = (int)Math.ceil((double)duree3 / 1000 * TauxEchantillon3);
byte echantillonaudio3[] = new byte[tailletampon3];
int i = 0;
while (i ‹nbEchantillons3) {
int j = 0;
while ((j ‹tailletampon3) && (i ‹nbEchantillons3)) {
int val3 = (int)(valMax3 * base3(i++, freq3, TauxEchantillon3));
if (nbOctets == 1) {
echantillonaudio3[j++] = (byte)val3;
} else if (bigEndian) {
echantillonaudio3[j++] = (byte)((val3 & 0xFF00) >> 8);
echantillonaudio3[j++] = (byte)(val3 & 0x00FF);
} else {
echantillonaudio3[j++] = (byte)(val3 & 0x00FF);
echantillonaudio3[j++] = (byte)((val3 & 0xFF00) >> 8);
}
}
onde3.write(echantillonaudio3, 0, j);
}
}
//fin onde 3
//debut onde 4
public static void face4(double freq4, long duree4, SourceDataLine onde4) {
AudioFormat jo4 = onde4.getFormat();
float TauxEchantillon4 = jo4.getSampleRate();
int tailletampon4 = onde4.getBufferSize();
int tailleEchantillon4 = jo4.getSampleSizeInBits();
int nbOctets = 0;
int valMax4 = 0;
if (tailleEchantillon4 == 8) {
nbOctets = 1;
valMax4 = 0x7F;
} else if (tailleEchantillon4 == 16) {
nbOctets = 2;
valMax4 = 0x7FFF;
} else {
throw new Error("# Nombre de bits par échantillon non supporté : " + tailleEchantillon4);
}
boolean bigEndian = jo4.isBigEndian();
int nbEchantillons4 = (int)Math.ceil((double)duree4 / 1000 * TauxEchantillon4);
byte echantillonaudio4[] = new byte[tailletampon4];
int i = 0;
while (i ‹nbEchantillons4) {
int j = 0;
while ((j ‹tailletampon4) && (i ‹nbEchantillons4)) {
int val4 = (int)(valMax4 * base2(i++, freq4, TauxEchantillon4));
if (nbOctets == 1) {
echantillonaudio4[j++] = (byte)val4;
} else if (bigEndian) {
echantillonaudio4[j++] = (byte)((val4 & 0xFF00) >> 8);
echantillonaudio4[j++] = (byte)(val4 & 0x00FF);
} else {
echantillonaudio4[j++] = (byte)(val4 & 0x00FF);
echantillonaudio4[j++] = (byte)((val4 & 0xFF00) >> 8);
}
}
onde4.write(echantillonaudio4, 0, j);
}
}
// fin onde 4
//onde 5
public static void face5(double freq5, long duree5, SourceDataLine onde5) {
AudioFormat jo5 = onde5.getFormat();
float TauxEchantillon5 = jo5.getSampleRate();
int tailletampon5 = onde5.getBufferSize();
int tailleEchantillon5 = jo5.getSampleSizeInBits();
int nbOctets = 0;
int valMax5 = 0;
if (tailleEchantillon5 == 8) {
nbOctets = 5;
valMax5 = 0x7F;
} else if (tailleEchantillon5 == 16) {
nbOctets = 2;
valMax5 = 0x7FFF;
} else {
throw new Error("# Nombre de bits par échantillon non supporté : " + tailleEchantillon5);
}
boolean bigEndian = jo5.isBigEndian();
int nbEchantillons = (int)Math.ceil((double)duree5 / 1000 * TauxEchantillon5);
byte echantillonaudio5[] = new byte[tailletampon5];
int i = 0;
while (i ‹nbEchantillons) {
int j = 0;
while ((j ‹tailletampon5) && (i ‹nbEchantillons)) {
int val5 = (int)(valMax5 * base5(i++, freq5, TauxEchantillon5));
if (nbOctets == 1) {
echantillonaudio5[j++] = (byte)val5;
} else if (bigEndian) {
echantillonaudio5[j++] = (byte)((val5 & 0xFF00) >> 8);
echantillonaudio5[j++] = (byte)(val5 & 0x00FF);
} else {
echantillonaudio5[j++] = (byte)(val5 & 0x00FF);
echantillonaudio5[j++] = (byte)((val5 & 0xFF00) >> 8);
}
}
onde5.write(echantillonaudio5, 0, j);
}
}
// fin onde 5
//onde 6
public static void face6(double freq6, long duree6, SourceDataLine onde6) {
AudioFormat jo6 = onde6.getFormat();
float TauxEchantillon6 = jo6.getSampleRate();
int tailletampon6 = onde6.getBufferSize();
int tailleEchantillon6 = jo6.getSampleSizeInBits();
int nbOctets = 0;
int valMax6 = 0;
if (tailleEchantillon6 == 8) {
nbOctets = 6;
valMax6 = 0x7F;
} else if (tailleEchantillon6 == 16) {
nbOctets = 2;
valMax6 = 0x7FFF;
} else {
throw new Error("# Nombre de bits par échantillon non supporté : " + tailleEchantillon6);
}
boolean bigEndian = jo6.isBigEndian();
int nbEchantillons = (int)Math.ceil((double)duree6 / 1000 * TauxEchantillon6);
byte echantillonaudio6[] = new byte[tailletampon6];
int i = 0;
while (i ‹nbEchantillons) {
int j = 0;
while ((j ‹tailletampon6) && (i ‹nbEchantillons)) {
int val6 = (int)(valMax6 * base6(i++, freq6, TauxEchantillon6));
if (nbOctets == 1) {
echantillonaudio6[j++] = (byte)val6;
} else if (bigEndian) {
echantillonaudio6[j++] = (byte)((val6 & 0xFF00) >> 8);
echantillonaudio6[j++] = (byte)(val6 & 0x00FF);
} else {
echantillonaudio6[j++] = (byte)(val6 & 0x00FF);
echantillonaudio6[j++] = (byte)((val6 & 0xFF00) >> 8);
}
}
onde6.write(echantillonaudio6, 0, j);
}
}
// fin onde 6
//onde 7
public static void face7(double freq7, long duree7, SourceDataLine onde7) {
AudioFormat jo7 = onde7.getFormat();
float TauxEchantillon7 = jo7.getSampleRate();
int tailletampon7 = onde7.getBufferSize();
int tailleEchantillon7 = jo7.getSampleSizeInBits();
int nbOctets = 0;
int valMax7 = 0;
if (tailleEchantillon7 == 8) {
nbOctets = 1;
valMax7 = 0x7F;
} else if (tailleEchantillon7 == 16) {
nbOctets = 2;
valMax7 = 0x7FFF;
} else {
throw new Error("# Nombre de bits par échantillon non supporté : " + tailleEchantillon7);
}
boolean bigEndian = jo7.isBigEndian();
int nbEchantillons = (int)Math.ceil((double)duree7 / 1000 * TauxEchantillon7);
byte echantillonaudio7[] = new byte[tailletampon7];
int i = 0;
while (i ‹nbEchantillons) {
int j = 0;
while ((j ‹tailletampon7) && (i ‹nbEchantillons)) {
int val7 = (int)(valMax7 * base7(i++, freq7, TauxEchantillon7));
if (nbOctets == 1) {
echantillonaudio7[j++] = (byte)val7;
} else if (bigEndian) {
echantillonaudio7[j++] = (byte)((val7 & 0xFF00) >> 8);
echantillonaudio7[j++] = (byte)(val7 & 0x00FF);
} else {
echantillonaudio7[j++] = (byte)(val7 & 0x00FF);
echantillonaudio7[j++] = (byte)((val7 & 0xFF00) >> 8);
}
}
onde7.write(echantillonaudio7, 0, j);
}
}
// fin onde 7
//debut onde 8
public static void face8(double freq8, long duree8, SourceDataLine onde8) {
AudioFormat jo8 = onde8.getFormat();
float TauxEchantillon8 = jo8.getSampleRate();
int tailletampon8 = onde8.getBufferSize();
int tailleEchantillon8 = jo8.getSampleSizeInBits();
int nbOctets = 0;
int valMax8 = 0;
if (tailleEchantillon8 == 8) {
nbOctets = 1;
valMax8 = 0x7F;
} else if (tailleEchantillon8 == 16) {
nbOctets = 8;
valMax8 = 0x7FFF;
} else {
throw new Error("# Nombre de bits par échantillon non supporté : " + tailleEchantillon8);
}
boolean bigEndian = jo8.isBigEndian();
int nbEchantillons = (int)Math.ceil((double)duree8 / 1000 * TauxEchantillon8);
byte echantillonaudio8[] = new byte[tailletampon8];
int i = 0;
while (i ‹nbEchantillons) {
int j = 0;
while ((j ‹tailletampon8) && (i ‹nbEchantillons)) {
int val8 = (int)(valMax8 * base8(i++, freq8, TauxEchantillon8));
if (nbOctets == 1) {
echantillonaudio8[j++] = (byte)val8;
} else if (bigEndian) {
echantillonaudio8[j++] = (byte)((val8 & 0xFF00) >> 8);
echantillonaudio8[j++] = (byte)(val8 & 0x00FF);
} else {
echantillonaudio8[j++] = (byte)(val8 & 0x00FF);
echantillonaudio8[j++] = (byte)((val8 & 0xFF00) >> 8);
}
}
onde8.write(echantillonaudio8, 0, j);
}
}
//fin onde 8
//debut onde 9
public static void face9(double freq9, long duree9, SourceDataLine onde9) {
AudioFormat jo9 = onde9.getFormat();
float TauxEchantillon9 = jo9.getSampleRate();
int tailletampon9 = onde9.getBufferSize();
int tailleEchantillon9 = jo9.getSampleSizeInBits();
int nbOctets = 0;
int valMax9 = 0;
if (tailleEchantillon9 == 8) {
nbOctets = 1;
valMax9 = 0x7F;
} else if (tailleEchantillon9 == 16) {
nbOctets = 2;
valMax9 = 0x7FFF;
} else {
throw new Error("# Nombre de bits par échantillon non supporté : " + tailleEchantillon9);
}
boolean bigEndian = jo9.isBigEndian();
int nbEchantillons9 = (int)Math.ceil((double)duree9 / 1000 * TauxEchantillon9);
byte echantillonaudio9[] = new byte[tailletampon9];
int i = 0;
while (i ‹nbEchantillons9) {
int j = 0;
while ((j ‹tailletampon9) && (i ‹nbEchantillons9)) {
int val9 = (int)(valMax9 * base9(i++, freq9, TauxEchantillon9));
if (nbOctets == 1) {
echantillonaudio9[j++] = (byte)val9;
} else if (bigEndian) {
echantillonaudio9[j++] = (byte)((val9 & 0xFF00) >> 8);
echantillonaudio9[j++] = (byte)(val9 & 0x00FF);
} else {
echantillonaudio9[j++] = (byte)(val9 & 0x00FF);
echantillonaudio9[j++] = (byte)((val9 & 0xFF00) >> 8);
}
}
onde9.write(echantillonaudio9, 0, j);
}
}
//fin onde 9
//debut onde 10
public static void face10(double freq10, long duree10, SourceDataLine onde10) {
AudioFormat jo10 = onde10.getFormat();
float TauxEchantillon10 = jo10.getSampleRate();
int tailletampon10 = onde10.getBufferSize();
int tailleEchantillon10 = jo10.getSampleSizeInBits();
int nbOctets = 0;
int valMax10 = 0;
if (tailleEchantillon10 == 8) {
nbOctets = 1;
valMax10 = 0x7F;
} else if (tailleEchantillon10 == 16) {
nbOctets = 2;
valMax10 = 0x7FFF;
} else {
throw new Error("# Nombre de bits par échantillon non supporté : " + tailleEchantillon10);
}
boolean bigEndian = jo10.isBigEndian();
int nbEchantillons10 = (int)Math.ceil((double)duree10 / 1000 * TauxEchantillon10);
byte echantillonaudio10[] = new byte[tailletampon10];
int i = 0;
while (i ‹nbEchantillons10) {
int j = 0;
while ((j ‹tailletampon10) && (i ‹nbEchantillons10)) {
int val10 = (int)(valMax10 * base2(i++, freq10, TauxEchantillon10));
if (nbOctets == 1) {
echantillonaudio10[j++] = (byte)val10;
} else if (bigEndian) {
echantillonaudio10[j++] = (byte)((val10 & 0xFF00) >> 8);
echantillonaudio10[j++] = (byte)(val10 & 0x00FF);
} else {
echantillonaudio10[j++] = (byte)(val10 & 0x00FF);
echantillonaudio10[j++] = (byte)((val10 & 0xFF00) >> 8);
}
}
onde10.write(echantillonaudio10, 0, j);
}
}
// fin onde 10
//onde 11
public static void face11(double freq11, long duree11, SourceDataLine onde11) {
AudioFormat jo11 = onde11.getFormat();
float TauxEchantillon11 = jo11.getSampleRate();
int tailletampon11 = onde11.getBufferSize();
int tailleEchantillon11 = jo11.getSampleSizeInBits();
int nbOctets = 0;
int valMax11 = 0;
if (tailleEchantillon11 == 8) {
nbOctets = 11;
valMax11 = 0x7F;
} else if (tailleEchantillon11 == 16) {
nbOctets = 2;
valMax11 = 0x7FFF;
} else {
throw new Error("# Nombre de bits par échantillon non supporté : " + tailleEchantillon11);
}
boolean bigEndian = jo11.isBigEndian();
int nbEchantillons = (int)Math.ceil((double)duree11 / 1000 * TauxEchantillon11);
byte echantillonaudio11[] = new byte[tailletampon11];
int i = 0;
while (i ‹nbEchantillons) {
int j = 0;
while ((j ‹tailletampon11) && (i ‹nbEchantillons)) {
int val11 = (int)(valMax11 * base11(i++, freq11, TauxEchantillon11));
if (nbOctets == 1) {
echantillonaudio11[j++] = (byte)val11;
} else if (bigEndian) {
echantillonaudio11[j++] = (byte)((val11 & 0xFF00) >> 8);
echantillonaudio11[j++] = (byte)(val11 & 0x00FF);
} else {
echantillonaudio11[j++] = (byte)(val11 & 0x00FF);
echantillonaudio11[j++] = (byte)((val11 & 0xFF00) >> 8);
}
}
onde11.write(echantillonaudio11, 0, j);
}
}
// fin onde 11
//onde 12
public static void face12(double freq12, long duree12, SourceDataLine onde12) {
AudioFormat jo12 = onde12.getFormat();
float TauxEchantillon12 = jo12.getSampleRate();
int tailletampon12 = onde12.getBufferSize();
int tailleEchantillon12 = jo12.getSampleSizeInBits();
int nbOctets = 0;
int valMax12 = 0;
if (tailleEchantillon12 == 8) {
nbOctets = 12;
valMax12 = 0x7F;
} else if (tailleEchantillon12 == 112) {
nbOctets = 2;
valMax12 = 0x7FFF;
} else {
throw new Error("# Nombre de bits par échantillon non supporté : " + tailleEchantillon12);
}
boolean bigEndian = jo12.isBigEndian();
int nbEchantillons = (int)Math.ceil((double)duree12 / 1000 * TauxEchantillon12);
byte echantillonaudio12[] = new byte[tailletampon12];
int i = 0;
while (i ‹nbEchantillons) {
int j = 0;
while ((j ‹tailletampon12) && (i ‹nbEchantillons)) {
int val12 = (int)(valMax12 * base12(i++, freq12, TauxEchantillon12));
if (nbOctets == 1) {
echantillonaudio12[j++] = (byte)val12;
} else if (bigEndian) {
echantillonaudio12[j++] = (byte)((val12 & 0xFF00) >> 8);
echantillonaudio12[j++] = (byte)(val12 & 0x00FF);
} else {
echantillonaudio12[j++] = (byte)(val12 & 0x00FF);
echantillonaudio12[j++] = (byte)((val12 & 0xFF00) >> 8);
}
}
onde12.write(echantillonaudio12, 0, j);
}
}
// fin onde 12
//ici nous indiquons quel va etre la forme de chaque onde
//en exemple pour les voyelles nous utilisons une fonction sinus
// pour les consonnes une fonction exponentielle
//debut forme d'onde 1
public static double base1(int i, double freq1, double pourcentage1) {
double temps1 = Math.IEEEremainder(i/pourcentage1, 1/freq1);
if (temps1 ‹0) {
temps1 += 1 / freq1;
}
double A = 0.4;
// return (A *Math.sin(2 * Math.PI * freq * temps1));
// return (A * Math.sin(2 * Math.PI * freq * temps1));
// return Math.exp(t)*(0.50 * Math.sin(freq * temps1 * Math.exp(1)));
return (A * Math.sin(2 * Math.PI * freq1 * temps1));
// return (A * Math.sin(freq1 * Math.exp(temps1)));
// return (A * Math.cos(2 * Math.PI * freq1 * temps1 + 1 ) * Math.cos(2 * Math.PI * freq1 * temps1 +1));
} //fin forme onde 1
//debut forme d'onde 2
public static double base2(int i, double freq2, double pourcentage2) {
double temps2 = Math.IEEEremainder(i/pourcentage2, 1/freq2);
if (temps2 ‹0) {
temps2 += 1 / freq2;
}
double A = 0.4; //amplitude
// return Math.exp(temps2)*(Math.sin(freq * temps2 ));
// return Math.exp(temps2)*(0.25 * Math.sin(freq * temps2 * Math.exp(1)));
// return (2 *A * Math.sin(2 * Math.PI * freq * temps2));
// return (2 * A * Math.sin(freq * temps2 * Math.exp(1)));
return ( A * Math.sin(2 * Math.PI * freq2 * temps2));
// return (2 *A* Math.sin(freq2 * Math.exp(temps2)));
// return (2 *A * Math.cos(2 * Math.PI * freq2 * temps2 + 1) * Math.cos(2 * Math.PI * freq2 * temps2 + 1));
} //fin forme onde 2
//debut forme d'onde 3
public static double base3(int i, double freq3, double pourcentage3) {
double temps3 = Math.IEEEremainder(i/pourcentage3, 1/freq3);
if (temps3 ‹0) {
temps3 += 1 / freq3;
}
double A = 0.4;
// return Math.exp(t)*(Math.sin(freq * temps3 ));
// return (3 * A * Math.sin(freq3 * temps3 * Math.exp(1)));
// return (3 * A * Math.sin(2 * Math.PI * freq3 * temps3));
return (A * Math.sin(2 * Math.PI * freq3 * temps3));
// return (3 * A * Math.sin(freq3 * Math.exp(temps3)));
// return (3 * A * Math.cos(2 * Math.PI * freq3 * temps3 + 1) * Math.cos(2 * Math.PI * freq3 * temps3 + 1));
}
//fin forme onde 3
//debut forme d'onde 4 ici une forme pour consonne donc onde cassante
public static double base4(int i, double freq4, double pourcentage4) {
double temps4 = Math.IEEEremainder(i/pourcentage4, 1/freq4);
if (temps4 ‹0) {
temps4 += 1 / freq4;
}
double A = 0.4;
// return (4 * A * Math.sin(2 * Math.PI * freq4 * temps4 + 1) * Math.cos(2 * Math.PI * freq4 * temps4 + 1));
// return Math.exp(temps4)*(Math.sin(freq4 * temps4 ));
// return (4 * A * Math.sin(freq * temps4 * Math.exp(1)));
// return (4 * A * Math.sin(2 * Math.PI * freq4 * temps4));
return (2 * A * Math.sin(2 * Math.PI * freq4 * temps4));
}
//fin forme onde 4
//forme onde 5
public static double base5(int i, double freq5, double pourcentage5) {
double temps5 = Math.IEEEremainder(i/pourcentage5, 1/freq5); if (temps5 ‹0) {
temps5 += 1 / freq5;
}
double A = 0.4;
// return (5 * A * Math.sin(2 * Math.PI * freq * temps5));
// return (5 * A * Math.sin(2 * Math.PI * freq * temps5));
// return Math.exp(t)*(0.50 * Math.sin(freq * temps5 * Math.exp(5)));
return ( A * Math.sin(2 * Math.PI * freq5 * temps5));
// return (5 * A * Math.sin(freq5 * Math.exp(temps5)));
// return (5 * A * Math.cos(2 * Math.PI * freq5 * temps5 + 1 ) * Math.cos(2 * Math.PI * freq5 * temps5 +1));
}
//fin forme onde 5
//forme onde 6
public static double base6(int i, double freq6, double pourcentage6) {
double temps6 = Math.IEEEremainder(i/pourcentage6, 1/freq6);
if (temps6 ‹0) {
temps6 += 1 / freq6;
}
double A = 0.4;
// return (0.26 *Math.sin(2 * Math.PI * freq * temps6));
// return (0.42 * Math.sin(2 * Math.PI * freq * temps6));
// return Math.exp(t)*(0.50 * Math.sin(freq * temps6 * Math.exp(6)));
return ( A * Math.sin(2 * Math.PI * freq6 * temps6));
// return (0.5 * Math.sin(freq6 * Math.exp(temps6)));
// return (0.125 * Math.cos(2 * Math.PI * freq6 * temps6 + 1 ) * Math.cos(2 * Math.PI * freq6 * temps6 +1));
}
//fin forme onde 6
//debut forme onde 7
public static double base7(int i, double freq7, double pourcentage7) {
double temps7 = Math.IEEEremainder(i/pourcentage7, 1/freq7);
if (temps7 ‹0) {
temps7 += 1 / freq7;
} double A = 0.4;
return (A * Math.sin(2 * Math.PI * freq7 * temps7));
}
//fin forme onde 7
//debut forme d'onde 8
public static double base8(int i, double freq8, double pourcentage8) {
double temps8 = Math.IEEEremainder(i/pourcentage8, 1/freq8);
if (temps8 ‹0) {
temps8 += 1 / freq8;
} double A = 0.4; //amplitude
return ( A * Math.sin(2 * Math.PI * freq8 * temps8));
}
//fin forme onde 8
//debut forme d'onde 9
public static double base9(int i, double freq9, double pourcentage9) {
double temps9 = Math.IEEEremainder(i/pourcentage9, 1/freq9);
if (temps9 ‹0) {
temps9 += 1 / freq9;
} double A = 0.4;
return ( A * Math.sin(2 * Math.PI * freq9 * temps9));
}
//fin forme onde 9
//debut forme d'onde 10
public static double base10(int i, double freq10, double pourcentage10) {
double temps10 = Math.IEEEremainder(i/pourcentage10, 1/freq10);
if (temps10 ‹0) {
temps10 += 1 / freq10;
} double A = 0.4;
return ( A * Math.sin(2 * Math.PI * freq10 * temps10));
} //fin forme onde 10
//debut forme d'onde 11
public static double base11(int i, double freq11, double pourcentage11) {
double temps11 = Math.IEEEremainder(i/pourcentage11, 1/freq11);
if (temps11 ‹0) {
temps11 += 1 / freq11;
}
double A = 0.4;
return ( A * Math.sin(2 * Math.PI * freq11 * temps11));
}
//fin forme onde 11
//forme onde 12
public static double base12(int i, double freq12, double pourcentage12) {
double temps12 = Math.IEEEremainder(i/pourcentage12, 1/freq12);
if (temps12 ‹0) {
temps12 += 1 / freq12;
}
double A = 0.4;
return (A * Math.sin(2 * Math.PI * freq12 * temps12));
}
//fin forme onde 12
public static void main(String args[]) {
final float TauxEchantillon1 = 20500;
final int tailleEchantillon1 = 8;
final float TauxEchantillon2 = 20500;
final int tailleEchantillon2 = 8;
final float TauxEchantillon3 = 20500;
final int tailleEchantillon3 = 8;
final float TauxEchantillon4 = 20500;
final int tailleEchantillon4 = 8;
final float TauxEchantillon5 = 20500;
final int tailleEchantillon5 = 8;
final float TauxEchantillon6 = 20500;
final int tailleEchantillon6 = 8;
final float TauxEchantillon7 = 20500;
final int tailleEchantillon7 = 8;
final float TauxEchantillon8 = 20500;
final int tailleEchantillon8 = 8;
final float TauxEchantillon9 = 20500;
final int tailleEchantillon9 = 8;
final float TauxEchantillon10 = 20500;
final int tailleEchantillon10 = 8;
final float TauxEchantillon11 = 20500;
final int tailleEchantillon11 = 8;
final float TauxEchantillon12 = 20500;
final int tailleEchantillon12 = 8;
final boolean bigEndian = true;
final boolean signed = true;
AudioFormat audiojo1 = new AudioFormat(TauxEchantillon1, tailleEchantillon1, 1, signed, bigEndian);
AudioFormat audiojo2 = new AudioFormat(TauxEchantillon2, tailleEchantillon2, 1, signed, bigEndian);
AudioFormat audiojo3 = new AudioFormat(TauxEchantillon3, tailleEchantillon3, 1, signed, bigEndian);
AudioFormat audiojo4 = new AudioFormat(TauxEchantillon4, tailleEchantillon4, 1, signed, bigEndian);
AudioFormat audiojo5 = new AudioFormat(TauxEchantillon5, tailleEchantillon5, 1, signed, bigEndian);
AudioFormat audiojo6 = new AudioFormat(TauxEchantillon6, tailleEchantillon6, 1, signed, bigEndian);
AudioFormat audiojo7 = new AudioFormat(TauxEchantillon7, tailleEchantillon7, 1, signed, bigEndian);
AudioFormat audiojo8 = new AudioFormat(TauxEchantillon8, tailleEchantillon8, 1, signed, bigEndian);
AudioFormat audiojo9 = new AudioFormat(TauxEchantillon9, tailleEchantillon9, 1, signed, bigEndian);
AudioFormat audiojo10 = new AudioFormat(TauxEchantillon10, tailleEchantillon10, 1, signed, bigEndian);
AudioFormat audiojo11 = new AudioFormat(TauxEchantillon11, tailleEchantillon11, 1, signed, bigEndian);
AudioFormat audiojo12 = new AudioFormat(TauxEchantillon12, tailleEchantillon12, 1, signed, bigEndian);
SourceDataLine onde1 = null;
SourceDataLine onde2 = null;
SourceDataLine onde3 = null;
SourceDataLine onde4 = null;
SourceDataLine onde5 = null;
SourceDataLine onde6 = null;
SourceDataLine onde7 = null;
SourceDataLine onde8 = null;
SourceDataLine onde9 = null;
SourceDataLine onde10 = null;
SourceDataLine onde11 = null;
SourceDataLine onde12 = null;
try {
onde1 = AudioSystem.getSourceDataLine(audiojo1);
onde1.open(audiojo1);
onde2 = AudioSystem.getSourceDataLine(audiojo2);
onde2.open(audiojo2);
onde3 = AudioSystem.getSourceDataLine(audiojo3);
onde3.open(audiojo3);
onde4 = AudioSystem.getSourceDataLine(audiojo4);
onde4.open(audiojo4);
onde5 = AudioSystem.getSourceDataLine(audiojo5);
onde5.open(audiojo5);
onde6 = AudioSystem.getSourceDataLine(audiojo6);
onde6.open(audiojo6);
onde7 = AudioSystem.getSourceDataLine(audiojo7);
onde7.open(audiojo7);
onde8 = AudioSystem.getSourceDataLine(audiojo8);
onde8.open(audiojo8);
onde9 = AudioSystem.getSourceDataLine(audiojo9);
onde9.open(audiojo9);
onde10 = AudioSystem.getSourceDataLine(audiojo10);
onde10.open(audiojo10);
onde11 = AudioSystem.getSourceDataLine(audiojo11);
onde11.open(audiojo11);
onde12 = AudioSystem.getSourceDataLine(audiojo12);
onde12.open(audiojo12);
} catch (LineUnavailableException lue) {
System.out.println("# Erreur : impossible de trouver une ligne de sortie audio au format :");
System.out.println("# " + audiojo1);
System.exit(1);
}
onde1.start();
onde2.start();
onde3.start();
onde4.start();
onde5.start();
onde6.start();
onde7.start();
onde8.start();
onde9.start();
onde10.start();
onde11.start();
onde12.start();
//ici commence les données à modifier pour jouer différents son
// variables pour les boucles
double B1 = 0 , B2 = 0 , B3 = 0 , B4 = 0 , B5 , B6 = 0 , B7 = 0;
// variables des durées
int Dur1 = 3 , Dur2 = 4 , Dur3 = 5;
//fréquence
double F1 = 0.5 * Math.exp(6) , F2 = 3 * F1 , F3 = 7 * F1 , F4 = 22 * F1;
// F1 est la forme de base, F2 donne la contenance, F3 entre 2800 et 3200 donne le timbre
// N6ous remarquons que l'intensité pour garder l'équilibre avec la fréquence est très importante
// l'intensité se réglant dans la forme de la courbe plus haut
//ici fini la fin des données, il reste la forme de la courbe aussi modifiable, ou ajouter des ondes
// /**
while (B7 <= 50) //le temps de l'onde est B2 boucles
{
B1 =0;
B2 =0;
B3 =0;
B4 =0;
B5 =0;
B6 =0;
while (B1 <= 30) //le temps de l'onde est 200 boucles
{
face1(F1, Dur1 , onde1); // onde F1 fixée au dessus
face2(F2, Dur1 , onde2);
face2(F3, Dur1 , onde3);
// face4(F4, Dur3 , onde4);
B1 = B1+1;
}
//B1 = 0;
while (B2 <= 30) //le temps de l'onde est 30 boucles
{
face1(F1, Dur2 , onde4); // onde F1 fixée au dessus
face2(F2, Dur2 , onde5);
face2(F3, Dur2 , onde6);
// face4(F4, Dur3 , onde4);
B2 = B2+1;
}
//B1 = 0;
while (B3 <= 30) //le temps de l'onde est 30 boucles
{
face1(F1, Dur3 , onde7); // onde F1 fixée au dessus
face2(F2, Dur3 , onde8);
face2(F3, Dur3 , onde9);
// face4(F4, Dur3 , onde4);
B3 = B3+1;
}
B1 = 0;
while (B4 <= 30) //le temps de l'onde est 200 boucles
{
face1(F1, Dur3 , onde10); // onde F1 fixée au dessus
face2(F2, Dur3 , onde11);
face2(F3, Dur3 , onde12);
// face4(F4, Dur3 , onde4);
B4 = B4+1;
}
B3 = 0;
while (B3 <= 30) //le temps de l'onde est 200 boucles
{
face1(F1, Dur3 , onde7); // onde F1 fixée au dessus
face2(F2, Dur3 , onde8);
face2(F3, Dur3 , onde9);
// face4(F4, Dur3 , onde4);
B3 = B3+1;
}
B2 = 0;
while (B2 <= 30) //le temps de l'onde est 200 boucles
{
face1(F1, Dur2 , onde4); // onde F1 fixée au dessus
face2(F2, Dur2 , onde5);
face2(F3, Dur2 , onde6);
// face4(F4, Dur3 , onde4);
B2 = B2+1;
}
B7 = B7 + 1;
B5 = (int) (B7%2);
if(B5 == 1)
{ F1 = F1 / ( F1 + 1 );
F2 = F2 / ( F2 + 1 );
F3 = F3 / ( F3 + 1 );
} // la variation en fréquence de l'onde est de
else
{F1 =F1 / ( F1 - 1 );
F2 = F2 / ( F2 - 1 );
F3 = F3 / ( F3 - 1 );
}
}
onde1.drain();
onde2.drain();
onde3.drain();
onde4.drain();
onde5.drain();
onde6.drain();
onde7.drain();
onde8.drain();
onde9.drain();
onde10.drain();
onde11.drain();
onde12.drain();

System.exit(0);
}

}