/*************************************debut du synthetiseur vocal****************************************/

/* Imaginer et creer par Abadie joris*/
/* en utilisant un concept de Andre pierre jocelyn*/
/* pour compiler : gcc play-4.c -lm -o play-4 -Wall*/
/*Cette oeuvre est protégée et n'est divulguée que pour utilisation sous linux dans les conditions Creative common ci-dessous*/
/* Cette oeuvre est mise à disposition selon les termes de la Licence Creative Commons Paternité - Pas d'Utilisation Commerciale - Partage des Conditions Initiales à l'Identique 2.0 France. */
/*Aucune garantie n'est donner sur les effets de cet executable*mais je peux dire qu'il fonctionne bien sur mes PC****/
/* pour compiler : gcc play-4.c -lm -o play-4 -Wall*/
/**le concept de cet executable reprend la perception des sciences comme pouvaient l'avoir les Celtes ou la Grèce antique.*/
/* A savoir qu'ils avaient nommés chaque dimension du nom d'un Dieu ou d'une entité et que chaque dimension possédait son propre système mathématique, l'assemblage du tout n'était qu'une histoire d'équilibre ainsi chez les Celtes c'est l'environnement qui faisait que le même symbole désignait un nom, une action, ils n'accordaient aucun absolue aux termes respectant ainsi les lois des sciences.*/
 /* Je pense que l'erreur de ces deux derniers millénaires est de ne pas avoir su reconnaitre que les trois grandes activités de l'esprit ( Dieu, les sciences, l'art) ne répondaient pas aux mêmes lois et d'avoir voulu leurs accorder les mêmes lois , ces trois activités se complètent et se grandissent mais ne sont pas de même nature
Ce n'est qu'un sentiment personnel ou un rève, mais il existe deux grandes périodes historiques, la première c'est les trois premiers siècles du christianisme quand les femmes faisaient la messe et sont venues jusqu'à nos cotes aux Saintes-Maries-de-la-Mer (un système sociale qui plaçait chaque nouveau né comme l'avenir de l'humanité quelque soit ses parents ou son lieu de vie, il avait droit à l'eau pure, aux nutriments, au respect et à l'amour poussant par la même les sciences en reniant les titres). Et le deuxième quand les chercheurs du siècles des lumières ont travaillé à l'aide d'équivalences arrivant ainsi à traduire les états d'équilibres quand ceux-ci étaient très simples.*/


#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <math.h>
#include <ctype.h>
#define total 256
#define total1 256
#define total2 256
#define efface "joris1.wav"


int fonctionlecteur ();
int FonctionEntete ();
int fonctionconvertisseur ();


/**********************************************************************************************************************************************/
long int longueurentete, nbdepoints, amplitudeentete, durerentete;
int sequence, sequence1, sequence2, actif, position, ausuivant, assemblage1, saitfait;
unsigned int calcultemps;

int fonctionlecteur()
{
	ausuivant = system("play joris1.wav");
	return ausuivant;
}
/* attenton : ignoring return value of system declared with attribut warm_unused_result*/

int FonctionEntete(int argc, char *argv[])
{

int abadie = 0;
int assemble =0;
durerentete = 0;
longueurentete = 0;
int ouaitu;
int force1 = 1;
int filtreabadiejoris = 1;
int compte = 1;
int groupe1;
int groupe2;


/*j ouvre mon fichier de donner*/
FILE* fichierjoa1 = NULL;

unsigned char tab1[total1] =
{0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x0A,0x0B,0x0C,0x0D,0x0E,0x0F,0x10,0x11,0x12,0x13,0x14,0x15,0x16,0x17,0x18,0x19,0x1A,0x1B,0x1C,0x1D,0x1E,0x1F,0x20,0x21,0x22,0x23,0x24,0x25,0x26,0x27,0x28,0x29,0x2A,0x2B,0x2C,0x2D,0x2E,0x2F,0x30,0x31,0x32,0x33,0x34,0x35,0x36,0x37,0x38,0x39,0x3A,0x3B,0x3C,0x3D,0x3E,0x3F,0x40,0x41,0x42,0x43,0x44,0x45,0x46,0x47,0x48,0x49,0x4A,0x4B,0x4C,0x4D,0x4E,0x4F,0x50,0x51,0x52,0x53,0x54,0x55,0x56,0x57,0x58,0x59,0x5A,0x5B,0x5C,0x5D,0x5E,0x5F,0x60,0x61,0x62,0x63,0x64,0x65,0x66,0x67,0x68,0x69,0x6A,0x6B,0x6C,0x6D,0x6E,0x6F,0x70,0x71,0x72,0x73,0x74,0x75,0x76,0x77,0x78,0x79,0x7A,0x7B,0x7C,0x7D,0x7E,0x7F,0x80,0x81,0x82,0x83,0x84,0x85,0x86,0x87,0x88,0x89,0x8A,0x8B,0x8C,0x8D,0x8E,0x8F,0x90,0x91,0x92,0x93,0x94,0x95,0x96,0x97,0x98,0x99,0x9A,0x9B,0x9C,0x9D,0x9E,0x9F,0xA0,0xA1,0xA2,0xA3,0xA4,0xA5,0xA6,0xA7,0xA8,0xA9,0xAA,0xAB,0xAC,0xAD,0xAE,0xAF,0xB0,0xB1,0xB2,0xB3,0xB4,0xB5,0xB6,0xB7,0xB8,0xB9,0xBA,0xBB,0xBC,0xBD,0xBE,0xBF,0xC0,0xC1,0xC2,0xC3,0xC4,0xC5,0xC6,0xC7,0xC8,0xC9,0xCA,0xCB,
0xCC,0xCD,0xCE,0xCF,0xD0,0xD1,0xD2,0xD3,0xD4,0xD5,0xD6,0xD7,0xD8,0xD9,0xDA,0xDB,0xDC,0xDD,0xDE,0xDF,0xE0,0xE1,0xE2,0xE3,0xE4,0xE5,0xE6,0xE7,0xE8,0xE9,0xEA,0xEB,0xEC,0xED,0xEE,0xEF,0xF0,0xF1,0xF2,0xF3,0xF4,0xF5,0xF6,0xF7,0xF8,0xF9,0xFA,0xFB,0xFC,0xFD,0xFE,0xFF};


fichierjoa1 = NULL;
  fichierjoa1 = fopen(argv[1], "rb");
  if(fichierjoa1 == NULL){
    printf("Ce fichier ne va pas %s\n",argv[1]);
    exit(1);
  }


if (fichierjoa1 != NULL)
{

/************************************************************************************************************************************/
abadie = fgetc(fichierjoa1); /* abadie vient chercher tout ce qui bouge*/
while (abadie != EOF)
{  /*acco1*/

switch (filtreabadiejoris) {/*acco2*/
case 1 :
compte++;
if (compte >10)
{filtreabadiejoris =2;}
break;

default:

assemble++;
/***debut assemble***/

switch (assemble) {/*acco3*/

case 1 :
/***laisse*passer*amplitude*pd faible**/
break;
case 2 :
/***laisse*passer*amplitude*pd fort**/
break;

case 3 :
for (ouaitu=0; ouaitu<255; ouaitu++)
{
if ( abadie == tab1[ouaitu])
{
groupe1 = ouaitu;

}
}
break;

default:
for (ouaitu=0; ouaitu<255; ouaitu++)
{
if ( abadie == tab1[ouaitu])
{
groupe2 = ouaitu;

}
}

force1 = groupe1 + (256 * groupe2);

nbdepoints = nbdepoints + (int)(force1);
assemble = 0;
} /***fin assemble***//*acco3*/
}/*acco2*/
abadie = fgetc(fichierjoa1); /* abadie va chercher la suivante*/
}/*acco1*/
fclose(fichierjoa1), fichierjoa1 = NULL;;
/****fin traitement bin******/


durerentete = nbdepoints ;

 calcultemps = ((unsigned int)durerentete )* 0.0441;
/*******************************************************************************************************************************************/

/*ici*je*commence*le*traitement*comme*jécris*chaque*base*de*temps*sur*deux*octets*je*multiplis*par*2*/


}

FILE* debutwav = NULL;
debutwav = fopen(efface, "wb+");
if (debutwav != NULL)
   {


  /*ici*je*commence*le*traitement*comme*jécris*chaque*base*de*temps*sur*deux*octets*je*multiplis*par*2*/
  int durerentete = durerentete * 2;
  int longueurentete = durerentete + 44 - 8;

  /****declaration**type**audio*4octets**/
  unsigned char riff[4] = { 0x52, 0x49, 0x46, 0x46 };
  fwrite (riff, 1, sizeof (riff), debutwav);

  /****longueurentete*du*fichier*audio*ici*21200**/
  fwrite (&longueurentete, sizeof (longueurentete), 1, debutwav);

  /****declaration**type**wave*4octets**/
  unsigned char wave[4] = { 0x57, 0x41, 0x56, 0x45 };
  fwrite (wave, 1, sizeof (wave), debutwav);

  /****declaration**type**fmt suivit d'un espace qui s'écrit 0x20 soit 4octets**/
  unsigned char fmt[4] = { 0x66, 0x6D, 0x74, 0x20 };
  fwrite (fmt, 1, sizeof (fmt), debutwav);

  /****declaration**de*la*maniere d'écrire*sous forme*d'un*entier long (unsigned int) soit 4octets**/
  /**comme c'est du 16 octets en exadécimal cela donne 0x10****/
  unsigned char poids[4] = { 0x10, 0x00, 0x00, 0x00 };
  fwrite (poids, 1, sizeof (poids), debutwav);

  /****codage pour indiquer le PCM c'est : 1 soit 2octets**/
  unsigned char pourpcm[2] = { 0x01, 0x00 };
  fwrite (pourpcm, 1, sizeof (pourpcm), debutwav);

  /****nombre de piste sur 2octets*ici c'est du mono, donc 1*/
  unsigned char piste[2] = { 0x01, 0x00 };
  fwrite (piste, 1, sizeof (piste), debutwav);

  /**nombre d'échantillons par seconde**sur 4 octets**/
  unsigned char tempsunitaire[4] = { 0x44, 0xAC, 0x00, 0x00 };
  fwrite (tempsunitaire, 1, sizeof (tempsunitaire), debutwav);

  /**nombre d'octets par secondes**sur 4 octets***le*double*du*précédent*dans*ce*cas*/
  unsigned char octetpars[4] = { 0x88, 0x58, 0x01, 0x00 };
  fwrite (octetpars, 1, sizeof (octetpars), debutwav);

  /*taille en octet d'1 échantillon***sur*2octets**/
  unsigned char tailleechant[2] = { 0x02, 0x00 };
  fwrite (tailleechant, 1, sizeof (tailleechant), debutwav);

  /*contient le nombre de bits par échantillon*2x8=16*soit*10*en*exa**sur*2octets**/
  unsigned char bitparechan[2] = { 0x10, 0x00 };
  fwrite (bitparechan, 1, sizeof (bitparechan), debutwav);

  /**On ecrit ici data pour dire que le fichier commence**sur 4cotets**/
  unsigned char mono[4] = { 0x64, 0x61, 0x74, 0x61 };
  fwrite (mono, 1, sizeof (mono), debutwav);

  fwrite (&durerentete, sizeof (durerentete), 1, debutwav);



fclose(debutwav), debutwav = NULL;;

   }
return 0;
}

/************fin*du createur**entete********************************************************************************/
/*********************************************************************************************************************************************/
int fonctionconvertisseur(int argc, char *argv[])

{

FonctionEntete(argc, argv);

int groupe1;
int groupe2;
int groupe3;
int groupe4;


/*j ouvre mon fichier de donner*/
FILE* jojo = NULL;

int abadie = 0;
int filtreabadiejoris = 2;
int compte = 1;


unsigned char tab1[total1] =
{0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x0A,0x0B,0x0C,0x0D,0x0E,0x0F,0x10,0x11,0x12,0x13,0x14,0x15,0x16,0x17,0x18,0x19,0x1A,0x1B,0x1C,0x1D,0x1E,0x1F,0x20,0x21,0x22,0x23,0x24,0x25,0x26,0x27,0x28,0x29,0x2A,0x2B,0x2C,0x2D,0x2E,0x2F,0x30,0x31,0x32,0x33,0x34,0x35,0x36,0x37,0x38,0x39,0x3A,0x3B,0x3C,0x3D,0x3E,0x3F,0x40,0x41,0x42,0x43,0x44,0x45,0x46,0x47,0x48,0x49,0x4A,0x4B,0x4C,0x4D,0x4E,0x4F,0x50,0x51,0x52,0x53,0x54,0x55,0x56,0x57,0x58,0x59,0x5A,0x5B,0x5C,0x5D,0x5E,0x5F,0x60,0x61,0x62,0x63,0x64,0x65,0x66,0x67,0x68,0x69,0x6A,0x6B,0x6C,0x6D,0x6E,0x6F,0x70,0x71,0x72,0x73,0x74,0x75,0x76,0x77,0x78,0x79,0x7A,0x7B,0x7C,0x7D,0x7E,0x7F,0x80,0x81,0x82,0x83,0x84,0x85,0x86,0x87,0x88,0x89,0x8A,0x8B,0x8C,0x8D,0x8E,0x8F,0x90,0x91,0x92,0x93,0x94,0x95,0x96,0x97,0x98,0x99,0x9A,0x9B,0x9C,0x9D,0x9E,0x9F,0xA0,0xA1,0xA2,0xA3,0xA4,0xA5,0xA6,0xA7,0xA8,0xA9,0xAA,0xAB,0xAC,0xAD,0xAE,0xAF,0xB0,0xB1,0xB2,0xB3,0xB4,0xB5,0xB6,0xB7,0xB8,0xB9,0xBA,0xBB,0xBC,0xBD,0xBE,0xBF,0xC0,0xC1,0xC2,0xC3,0xC4,0xC5,0xC6,0xC7,0xC8,0xC9,0xCA,0xCB,
0xCC,0xCD,0xCE,0xCF,0xD0,0xD1,0xD2,0xD3,0xD4,0xD5,0xD6,0xD7,0xD8,0xD9,0xDA,0xDB,0xDC,0xDD,0xDE,0xDF,0xE0,0xE1,0xE2,0xE3,0xE4,0xE5,0xE6,0xE7,0xE8,0xE9,0xEA,0xEB,0xEC,0xED,0xEE,0xEF,0xF0,0xF1,0xF2,0xF3,0xF4,0xF5,0xF6,0xF7,0xF8,0xF9,0xFA,0xFB,0xFC,0xFD,0xFE,0xFF};


  jojo = fopen(argv[1], "rb");
  if(jojo == NULL){
    printf("Ce fichier ne va pas %s\n", argv[1]);
    exit(1);
  }

if (jojo != NULL)
{

int assemble = 0;
int ludion = 32768;
int enclanche = 0;
int nbdepoints;

int ouaitu;
int amplitude = 32768;
int force1 = 0;
int joencour;
float jo;

abadie = fgetc(jojo); /* abadie vient chercher tout ce qui bouge*/
while (abadie != EOF)
{

switch (filtreabadiejoris) {
case 1 :
compte++;
if (compte >12)
{filtreabadiejoris = 2;}
break;

default:

for (ouaitu=0; ouaitu<255; ouaitu++)
{
if ( abadie == tab1[ouaitu])
{
force1 = ouaitu;
assemble++;
}
}
/***debut assemble***/

switch (assemble) {
/****************************traitement*amplitude****/


case 1 :
groupe1 = force1 ;
break;

case 2 :
groupe2 = (force1 * 256);
amplitude = groupe1 + groupe2 ;
break;

case 3 :
groupe3 = force1;
break;

default:
groupe4 = (force1 * 256);
nbdepoints = groupe3 + groupe4 ;


/****fin traitement bin******/
joencour = 17;
float okioki ;
float okioki1 ;
okioki = (float)(nbdepoints);
okioki1 = (float)(joencour);

jo = (okioki * okioki1 * (0.01));


if (jo < 2){ jo = 1; }
int sens;
if (ludion > amplitude) { sens = 2; }
else { sens = 1; }

/***fin conversion***/
double codebash;

FILE* temps = NULL;

char tab[total] = {0x80,0x81,0x82,0x83,0x84,0x85,0x86,0x87,0x88,0x89,0x8A,0x8B,0x8C,0x8D,0x8E,0x8F,0x90,0x91,0x92,0x93,0x94,0x95,0x96,0x97,0x98,0x99,0x9A,0x9B,0x9C,0x9D,0x9E,0x9F,0xA0,0xA1,0xA2,0xA3,0xA4,0xA5,0xA6,0xA7,0xA8,0xA9,0xAA,0xAB,0xAC,0xAD,0xAE,0xAF,0xB0,0xB1,0xB2,0xB3,0xB4,0xB5,0xB6,0xB7,0xB8,0xB9,0xBA,0xBB,0xBC,0xBD,0xBE,0xBF,0xC0,0xC1,0xC2,0xC3,0xC4,0xC5,0xC6,0xC7,0xC8,0xC9,0xCA,0xCB,0xCC,0xCD,0xCE,0xCF,0xD0,0xD1,0xD2,0xD3,0xD4,0xD5,0xD6,0xD7,0xD8,0xD9,0xDA,0xDB,0xDC,0xDD,0xDE,0xDF,0xE0,0xE1,0xE2,0xE3,0xE4,0xE5,0xE6,0xE7,0xE8,0xE9,0xEA,0xEB,0xEC,0xED,0xEE,0xEF,0xF0,0xF1,0xF2,0xF3,0xF4,0xF5,0xF6,0xF7,0xF8,0xF9,0xFA,0xFB,0xFC,0xFD,0xFE,0xFF,0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x0A,0x0B,0x0C,0x0D,0x0E,0x0F,0x10,0x11,0x12,0x13,0x14,0x15,0x16,0x17,0x18,0x19,0x1A,0x1B,0x1C,0x1D,0x1E,0x1F,0x20,0x21,0x22,0x23,0x24,0x25,0x26,0x27,0x28,0x29,0x2A,0x2B,0x2C,0x2D,0x2E,0x2F,0x30,0x31,0x32,0x33,0x34,0x35,0x36,0x37,0x38,0x39,0x3A,0x3B,0x3C,0x3D,0x3E,0x3F,0x40,0x41,0x42,0x43,0x44,0x45,0x46,0x47,0x48,
0x49,0x4A,0x4B,0x4C,0x4D,0x4E,0x4F,0x50,0x51,0x52,0x53,0x54,0x55,0x56,0x57,0x58,0x59,0x5A,0x5B,0x5C,0x5D,0x5E,0x5F,0x60,0x61,0x62,0x63,0x64,0x65,0x66,0x67,0x68,0x69,0x6A,0x6B,0x6C,0x6D,0x6E,0x6F,0x70,0x71,0x72,0x73,0x74,0x75,0x76,0x77,0x78,0x79,0x7A,0x7B,0x7C,0x7D,0x7E,0x7F};



char *ptr;
char *petr;


temps = fopen(efface, "ab"); /* pour ajouter a. possible w ou r+ w+ tester */

if (temps != NULL)

{





/*******/

if(sens == 2)

/*ajouter dessous*/
{


if ( nbdepoints < 2)
{
codebash = (int)(amplitude);



int ji;
int ij;
int ola;
ola = (int)codebash;

/*ji = ola%256;*/
ij = (int)(ola*0.00390625);
ji = ola - (256*ij);

ptr = &tab[ji];
petr = &tab[ij];


fwrite( ptr, sizeof(char), 1, temps);
fwrite( petr, sizeof(char), 1, temps);


}



else
{


 float ote, ote1;
int boucle;
boucle = nbdepoints * 0.5;

int reste;
reste = nbdepoints - boucle;

ote = (ludion - amplitude) * 0.5;




while ( boucle > 0)





{
ote1 = ote * ( 1 - exp (-boucle/jo));

/*
fprintf(temps,"%d ", (int)codebash );
*/


codebash = (int)( amplitude + ote + ote1);


int ji;
int ij;
int ola;
ola = (int)codebash;

/*ji = ola%256;*/
ij = (int)(ola*0.00390625);
ji = ola - (256*ij);

ptr = &tab[ji];
petr = &tab[ij];


fwrite( ptr, sizeof(char), 1, temps);
fwrite( petr, sizeof(char), 1, temps);





/*fin modif*/
boucle--;

}


enclanche = 2; /*** deuxieme enclanche du sens 2**********/

if ( enclanche == 2)
{




 float ote, ote1;

ote = (ludion - amplitude) * 0.5;



int boucle1 = 1;
while (boucle1 < reste + 1)
{

ote1 = ote * ( 1 - exp (-boucle1/jo));




codebash = (int) ( ludion - ote -ote1);


int ji;
int ij;
int ola;
ola = (int)codebash;

/*ji = ola%256;*/
ij = (int)(ola*0.00390625);
ji = ola - (256*ij);

ptr = &tab[ji];
petr = &tab[ij];


fwrite( ptr, sizeof(char), 1, temps);
fwrite( petr, sizeof(char), 1, temps);






/*fin modif*/

boucle1++;

}



enclanche = 0;




/* fin descente 2*/


}
}

}


/*en attente*/

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

if(sens == 1)
{
if ( nbdepoints < 2)
{
codebash = (int)(amplitude);



int ji;
int ij;
int ola;
ola = (int)codebash;

/*ji = ola%256;*/
ij = (int)(ola*0.00390625);
ji = ola - (256*ij);

ptr = &tab[ji];
petr = &tab[ij];


fwrite( ptr, sizeof(char), 1, temps);
fwrite( petr, sizeof(char), 1, temps);


}


else
{


 float ote, ote1;



int boucle;
boucle = nbdepoints * 0.5;
int ajuste;
ajuste = nbdepoints - boucle;

if ( boucle == 0)
{
boucle = 1;
}


ote = ( amplitude - ludion ) * 0.5;




while ( boucle > 0)
{

ote1 = ote * ( 1 - exp (-boucle/jo));

codebash = amplitude - ote - ote1;
/*
fprintf(temps,"%d ", (int)codebash );
*/



codebash = (int)(amplitude - ote - ote1);



int ji;
int ij;
int ola;
ola = (int)codebash;

/*ji = ola%256;*/
ij = (int)(ola*0.00390625);
ji = ola - (256*ij);

ptr = &tab[ji];
petr = &tab[ij];


fwrite( ptr, sizeof(char), 1, temps);
fwrite( petr, sizeof(char), 1, temps);


/*fin modif*/
boucle--;

}

enclanche = 1;
/* debut descente inverse du sens 1 */
if (enclanche == 1)

{


 float ote, ote1;
int boucle, boncompte;
boucle = 1;

ote = ( amplitude - ludion ) * 0.5;
boncompte = ajuste;
if (boncompte == 0)
{
boncompte = 1;
}


while (boucle < (boncompte+1))


{
ote1 = ote * ( 1 - exp (-boucle/jo));




codebash = (int) (ludion + ote + ote1);


int ji;
int ij;
int ola;
ola = (int)codebash;

/*ji = ola%256;*/
ij = (int)(ola*0.00390625);
ji = ola - (256*ij);

ptr = &tab[ji];
petr = &tab[ij];


fwrite( ptr, sizeof(char), 1, temps);
fwrite( petr, sizeof(char), 1, temps);






/*fin modif*/
boucle++;
}


enclanche = 0;

}

}


}


/* fin*/






/********/


/*****/



fclose(temps), temps = NULL;;
}
ludion = amplitude;

/*pas*toucher*/
assemble = 0;
} /***fin assemble***/
}
abadie = fgetc(jojo); /* abadie va chercher la suivante*/
}
fclose(jojo), jojo = NULL;;


}






	ausuivant = fonctionlecteur();
	if (ausuivant == EOF);

return 0;
}

/************************fin fonction***/
/*****fonction main**/

int main(int argc, char *argv[]) {

	FonctionEntete(argc, argv);
	fonctionconvertisseur(argc,argv);/*je lance la lecture*audio du fichier .jo en argument*/
        return 0 ;

    }